home *** CD-ROM | disk | FTP | other *** search
/ MacFormat 1995 January / macformat-020.iso / Shareware City / Developers / OutOfPhase1.01Source / OutOfPhase Folder / SampleOscControl.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-10-01  |  75.2 KB  |  2,211 lines  |  [TEXT/KAHL]
  1. /* SampleOscControl.c */
  2. /*****************************************************************************/
  3. /*                                                                           */
  4. /*    Out Of Phase:  Digital Music Synthesis on General Purpose Computers    */
  5. /*    Copyright (C) 1994  Thomas R. Lawrence                                 */
  6. /*                                                                           */
  7. /*    This program is free software; you can redistribute it and/or modify   */
  8. /*    it under the terms of the GNU General Public License as published by   */
  9. /*    the Free Software Foundation; either version 2 of the License, or      */
  10. /*    (at your option) any later version.                                    */
  11. /*                                                                           */
  12. /*    This program is distributed in the hope that it will be useful,        */
  13. /*    but WITHOUT ANY WARRANTY; without even the implied warranty of         */
  14. /*    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          */
  15. /*    GNU General Public License for more details.                           */
  16. /*                                                                           */
  17. /*    You should have received a copy of the GNU General Public License      */
  18. /*    along with this program; if not, write to the Free Software            */
  19. /*    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.              */
  20. /*                                                                           */
  21. /*    Thomas R. Lawrence can be reached at tomlaw@world.std.com.             */
  22. /*                                                                           */
  23. /*****************************************************************************/
  24.  
  25. #include "MiscInfo.h"
  26. #include "Audit.h"
  27. #include "Debug.h"
  28. #include "Definitions.h"
  29.  
  30. #include "SampleOscControl.h"
  31. #include "64BitMath.h"
  32. #include "Multisampler.h"
  33. #include "EnvelopeState.h"
  34. #include "Envelope.h"
  35. #include "LFOGenerator.h"
  36. #include "LFOListSpecifier.h"
  37. #include "SampleConsts.h"
  38. #include "Memory.h"
  39. #include "OscillatorSpecifier.h"
  40. #include "FastModulation.h"
  41. #include "ErrorDaemon.h"
  42.  
  43.  
  44. #if !MEMDEBUG && DEBUG
  45.     #undef PRNGCHK
  46.     #define PRNGCHK(x,y,z) ((void)0)
  47. #endif
  48.  
  49.  
  50. /* prototypes for fast playback routines */
  51. static void                        Sample_MonoOut_MonoSamp_8BitIn_NoTime(SampleStateRec* State,
  52.                                                 long SampleCount, largefixedsigned* RawBuffer);
  53. static void                        Sample_StereoOut_MonoSamp_8BitIn_NoTime(SampleStateRec* State,
  54.                                                 long SampleCount, largefixedsigned* RawBuffer);
  55. static void                        Sample_MonoOut_StereoSamp_8BitIn_NoTime(SampleStateRec* State,
  56.                                                 long SampleCount, largefixedsigned* RawBuffer);
  57. static void                        Sample_StereoOut_StereoSamp_8BitIn_NoTime(SampleStateRec* State,
  58.                                                 long SampleCount, largefixedsigned* RawBuffer);
  59.  
  60. static void                        Sample_MonoOut_MonoSamp_16BitIn_NoTime(SampleStateRec* State,
  61.                                                 long SampleCount, largefixedsigned* RawBuffer);
  62. static void                        Sample_StereoOut_MonoSamp_16BitIn_NoTime(SampleStateRec* State,
  63.                                                 long SampleCount, largefixedsigned* RawBuffer);
  64. static void                        Sample_MonoOut_StereoSamp_16BitIn_NoTime(SampleStateRec* State,
  65.                                                 long SampleCount, largefixedsigned* RawBuffer);
  66. static void                        Sample_StereoOut_StereoSamp_16BitIn_NoTime(SampleStateRec* State,
  67.                                                 long SampleCount, largefixedsigned* RawBuffer);
  68.  
  69. static void                        Sample_MonoOut_MonoSamp_8BitIn_YesTime(SampleStateRec* State,
  70.                                                 long SampleCount, largefixedsigned* RawBuffer);
  71. static void                        Sample_StereoOut_MonoSamp_8BitIn_YesTime(SampleStateRec* State,
  72.                                                 long SampleCount, largefixedsigned* RawBuffer);
  73. static void                        Sample_MonoOut_StereoSamp_8BitIn_YesTime(SampleStateRec* State,
  74.                                                 long SampleCount, largefixedsigned* RawBuffer);
  75. static void                        Sample_StereoOut_StereoSamp_8BitIn_YesTime(SampleStateRec* State,
  76.                                                 long SampleCount, largefixedsigned* RawBuffer);
  77.  
  78. static void                        Sample_MonoOut_MonoSamp_16BitIn_YesTime(SampleStateRec* State,
  79.                                                 long SampleCount, largefixedsigned* RawBuffer);
  80. static void                        Sample_StereoOut_MonoSamp_16BitIn_YesTime(SampleStateRec* State,
  81.                                                 long SampleCount, largefixedsigned* RawBuffer);
  82. static void                        Sample_MonoOut_StereoSamp_16BitIn_YesTime(SampleStateRec* State,
  83.                                                 long SampleCount, largefixedsigned* RawBuffer);
  84. static void                        Sample_StereoOut_StereoSamp_16BitIn_YesTime(SampleStateRec* State,
  85.                                                 long SampleCount, largefixedsigned* RawBuffer);
  86.  
  87. static void                        Sample_NoOutput(SampleStateRec* State,
  88.                                                 long SampleCount, largefixedsigned* RawBuffer);
  89.  
  90.  
  91. /* this is used for loop control */
  92. typedef enum
  93.     {
  94.         eRepeatingLoop1 EXECUTE(= -18734),
  95.         eRepeatingLoop2,
  96.         eRepeatingLoop3,
  97.         eNoLoop,
  98.         eSampleFinished
  99.     } LoopType;
  100.  
  101.  
  102. /* sample oscillator template information record */
  103. struct SampleTemplateRec
  104.     {
  105.         /* source information for the sample */
  106.         MultiSampleRec*                SampleSourceSelector;
  107.  
  108.         /* sampling rate for final output */
  109.         long                                    FinalOutputSamplingRate;
  110.         /* number of envelope updates per second */
  111.         float                                    EnvelopeTicksPerSecond;
  112.  
  113.         /* values for scaling the frequency of something.  if we were really serious about */
  114.         /* this, we'd traverse all of the oscillators with integral multiples or harmonic */
  115.         /* fractions of the pitch & set their differentials to the same precision as the */
  116.         /* worst oscillator so that they would all stay in sync as time progressed. */
  117.         float                                    FrequencyMultiplier;
  118.  
  119.         /* stereo status */
  120.         NumChannelsType                StereoPlayback;
  121.         /* time interpolation flag */
  122.         MyBoolean                            InterpolateThroughTime;
  123.         /* inter-wave interpolation flag */
  124.         MyBoolean                            InterpolateAcrossWaves; /* not used now -- for future use */
  125.         /* include in final output flag */
  126.         MyBoolean                            IncludeInFinalOutput;
  127.  
  128.         /* envelope templates */
  129.         EnvelopeRec*                    LoudnessEnvelopeTemplate;
  130.         LFOListSpecRec*                LoudnessLFOTemplate;
  131.  
  132.         /* miscellaneous control parameters */
  133.         float                                    StereoBias;
  134.         float                                    TimeDisplacement;
  135.         float                                    OverallOscillatorLoudness;
  136.  
  137.         /* error logging facility */
  138.         ErrorDaemonRec*                ErrorDaemon;
  139.  
  140.         /* link for list control */
  141.         SampleTemplateRec*        Next;
  142.     };
  143.  
  144.  
  145. /* sample oscillator state record */
  146. struct SampleStateRec
  147.     {
  148.         /* current sample position into the array */
  149.         LongLongRec                        SamplePosition; /* 32-bit fixed point */
  150.         /* current increment value for the sample position */
  151.         LongLongRec                        SamplePositionDifferential; /* 32-bit fixed point */
  152.         /* envelope tick countdown for pre-start time */
  153.         long                                    PreStartCountdown;
  154.  
  155.         /* function for generating a bunch of sample points */
  156.         void                                    (*SampleGenSamples)(SampleStateRec* State,
  157.                                                         long SampleCount, largefixedsigned* RawBuffer);
  158.  
  159.         /* number of frames in the sample */
  160.         long                                    NumFrames;
  161.         /* sample data pointer.  for mono, it is just an array.  for stereo, the */
  162.         /* samples are interleaved, left channel first */
  163.         void*                                    Data;
  164.         /* number of bits in the data for the sample */
  165.         NumBitsType                        NumBits;
  166.         /* stereo or mono sample */
  167.         NumChannelsType                NumChannels;
  168.  
  169.         /* control parameters for the sample */
  170.         float                                    NaturalFrequency;
  171.         long                                    SamplingRate;
  172.         long                                    OriginPoint;
  173.         long                                    Loop1Start;
  174.         long                                    Loop2Start;
  175.         long                                    Loop3Start;
  176.         long                                    Loop1End;
  177.         long                                    Loop2End;
  178.         long                                    Loop3End;
  179.         /* state information for the current position */
  180.         LoopType                            LoopState; /* which loop is running */
  181.         long                                    CurrentLoopLength; /* current loop length (end - start) */
  182.         long                                    CurrentLoopEnd; /* current loop/total end point */
  183.  
  184.         /* NOTE:  either OverallLoudness or Left/RightLoudness are used, but not both */
  185.         /* current overall loudness for oscillator */
  186.         FastFixedType                    OverallLoudness; /* 15-bit fixed point, 0..1 */
  187.         /* left channel loudness */
  188.         FastFixedType                    LeftLoudness; /* 15-bit fixed point, 0..1 */
  189.         /* right channel loudness */
  190.         FastFixedType                    RightLoudness; /* 15-bit fixed point, 0..1 */
  191.         /* panning position for splitting envelope generator into stereo channels */
  192.         /* 0 = left channel, 0.5 = middle, 1 = right channel */
  193.         FastFixedType                    Panning; /* 15-bit fixed point, 0..1 */
  194.         /* envelope that is generating the loudness information */
  195.         EvalEnvelopeRec*            SampleLoudnessEnvelope;
  196.         /* LFO generators modifying the output of the loudness envelope generator */
  197.         LFOGenRec*                        LoudnessLFOGenerator;
  198.  
  199.         /* this flag is True if the sample data was defined at the specified pitch */
  200.         /* (and the sample vectors are thus valid) or False if there is no sample */
  201.         /* at this pitch (and the arrays are invalid) */
  202.         MyBoolean                            SampleWasDefined;
  203.  
  204.         /* this field contains the overall volume scaling for everything so that we */
  205.         /* can treat the envelopes as always going between 0 and 1. */
  206.         float                                    NoteLoudnessScaling;
  207.  
  208.         /* static information for the sample */
  209.         SampleTemplateRec            Template; /* a copy of the data */
  210.  
  211.         /* link for list control */
  212.         SampleStateRec*                Next;
  213.     };
  214.  
  215.  
  216.  
  217.  
  218. static SampleTemplateRec*                SampleTemplateFreeList = NIL;
  219. static SampleStateRec*                    SampleStateFreeList = NIL;
  220.  
  221.  
  222. /* get rid of all cached memory for state or template records */
  223. void                                    FlushSampleOscControl(void)
  224.     {
  225.         while (SampleTemplateFreeList != NIL)
  226.             {
  227.                 SampleTemplateRec*    Temp;
  228.  
  229.                 Temp = SampleTemplateFreeList;
  230.                 SampleTemplateFreeList = SampleTemplateFreeList->Next;
  231.                 ReleasePtr((char*)Temp);
  232.             }
  233.  
  234.         while (SampleStateFreeList != NIL)
  235.             {
  236.                 SampleStateRec*            Temp;
  237.  
  238.                 Temp = SampleStateFreeList;
  239.                 SampleStateFreeList = SampleStateFreeList->Next;
  240.                 ReleasePtr((char*)Temp);
  241.             }
  242.     }
  243.  
  244.  
  245. #if DEBUG
  246. static void                        CheckValidSampleTemplate(SampleTemplateRec* Object)
  247.     {
  248.         SampleTemplateRec*    Scan;
  249.  
  250.         Scan = SampleTemplateFreeList;
  251.         while (Scan != NIL)
  252.             {
  253.                 if (Scan == Object)
  254.                     {
  255.                         PRERR(ForceAbort,"CheckValidSampleTemplate:  template is on free list");
  256.                     }
  257.                 Scan = Scan->Next;
  258.             }
  259.     }
  260. #else
  261. #define CheckValidSampleTemplate(x) ((void)0)
  262. #endif
  263.  
  264.  
  265. #if DEBUG
  266. static void                        CheckValidSampleState(SampleStateRec* Object)
  267.     {
  268.         SampleStateRec*            Scan;
  269.  
  270.         Scan = SampleStateFreeList;
  271.         while (Scan != NIL)
  272.             {
  273.                 if (Scan == Object)
  274.                     {
  275.                         PRERR(ForceAbort,"CheckValidSampleState:  state is on free list");
  276.                     }
  277.                 Scan = Scan->Next;
  278.             }
  279.     }
  280. #else
  281. #define CheckValidSampleState(x) ((void)0)
  282. #endif
  283.  
  284.  
  285. /* perform one envelope update cycle */
  286. void                                    UpdateSampleEnvelopes(SampleStateRec* State)
  287.     {
  288.         FastFixedType                Temp;
  289.  
  290.         CheckPtrExistence(State);
  291.         CheckValidSampleState(State);
  292.  
  293.         /* this is for the benefit of resampling only -- envelope generators do their */
  294.         /* own pre-origin sequencing */
  295.         if (State->PreStartCountdown > 0)
  296.             {
  297.                 State->PreStartCountdown -= 1;
  298.             }
  299.  
  300.         Temp = State->NoteLoudnessScaling * LFOGenUpdateCycle(State->LoudnessLFOGenerator,
  301.             EnvelopeUpdate(State->SampleLoudnessEnvelope));
  302.         /* fast fixed has a very narrow range, so overflow can't be permitted: */
  303.         /* 15x15->30 bits, with 2 extra bits; we use one for sign and the other */
  304.         /* to permit the representation of 1 and -1. */
  305.         if (State->Template.StereoPlayback == eSampleMono)
  306.             {
  307.                 if (Temp < - Int2FastFixed(1))
  308.                     {
  309.                         ErrorDaemonReportClamping(State->Template.ErrorDaemon,
  310.                             - FastFixed2Float(Temp));
  311.                         Temp = - Int2FastFixed(1);
  312.                     }
  313.                 else if (Temp > Int2FastFixed(1))
  314.                     {
  315.                         ErrorDaemonReportClamping(State->Template.ErrorDaemon,
  316.                             FastFixed2Float(Temp));
  317.                         Temp = Int2FastFixed(1);
  318.                     }
  319.                 State->OverallLoudness = Temp;
  320.             }
  321.          else
  322.             {
  323.                 FastFixedType                LeftVolumeScaling;
  324.                 FastFixedType                RightVolumeScaling;
  325.                 FastFixedType                MaxVolScaling;
  326.                 FastFixedType                MaxTemp;
  327.  
  328.                 LeftVolumeScaling = FastFixedTimesFastFixedToFastFixed(Double2FastFixed(0.5),
  329.                     Int2FastFixed(1) - State->Panning);
  330.                 RightVolumeScaling = FastFixedTimesFastFixedToFastFixed(Double2FastFixed(0.5),
  331.                     Int2FastFixed(1) + State->Panning);
  332.  
  333.                 if (((LeftVolumeScaling >= 0) ? LeftVolumeScaling : (- LeftVolumeScaling))
  334.                     > ((RightVolumeScaling >= 0) ? RightVolumeScaling : (- RightVolumeScaling)))
  335.                     {
  336.                         MaxVolScaling = ((LeftVolumeScaling >= 0)
  337.                             ? LeftVolumeScaling : (- LeftVolumeScaling));
  338.                     }
  339.                  else
  340.                     {
  341.                         MaxVolScaling = ((RightVolumeScaling >= 0)
  342.                             ? RightVolumeScaling : (- RightVolumeScaling));
  343.                     }
  344.                 MaxTemp = Double2FastFixed((float)1 / FastFixed2Float(MaxVolScaling));
  345.                 if (Temp < - MaxTemp)
  346.                     {
  347.                         ErrorDaemonReportClamping(State->Template.ErrorDaemon,
  348.                             - FastFixed2Float(Temp) / FastFixed2Float(MaxTemp));
  349.                         Temp = - MaxTemp;
  350.                     }
  351.                 else if (Temp > MaxTemp)
  352.                     {
  353.                         ErrorDaemonReportClamping(State->Template.ErrorDaemon,
  354.                             FastFixed2Float(Temp) / FastFixed2Float(MaxTemp));
  355.                         Temp = MaxTemp;
  356.                     }
  357.  
  358.                 State->LeftLoudness = FastFixedTimesFastFixedToFastFixed(
  359.                     LeftVolumeScaling,Temp);
  360.                 State->RightLoudness = FastFixedTimesFastFixedToFastFixed(
  361.                     RightVolumeScaling,Temp);
  362.             }
  363.     }
  364.  
  365.  
  366. /* dispose of the sample state record */
  367. void                                    DisposeSampleState(SampleStateRec* State)
  368.     {
  369.         CheckPtrExistence(State);
  370.         CheckValidSampleState(State);
  371.  
  372.         DisposeEnvelopeStateRecord(State->SampleLoudnessEnvelope);
  373.         DisposeLFOGenerator(State->LoudnessLFOGenerator);
  374.  
  375.         State->Next = SampleStateFreeList;
  376.         SampleStateFreeList = State;
  377.     }
  378.  
  379.  
  380. /* dispose of the sample information template */
  381. void                                    DisposeSampleTemplate(SampleTemplateRec* Template)
  382.     {
  383.         CheckPtrExistence(Template);
  384.         CheckValidSampleTemplate(Template);
  385.  
  386.         DisposeMultisample(Template->SampleSourceSelector);
  387.  
  388.         Template->Next = SampleTemplateFreeList;
  389.         SampleTemplateFreeList = Template;
  390.     }
  391.  
  392.  
  393. /* create a new sample template */
  394. SampleTemplateRec*        NewSampleTemplate(struct OscillatorRec* Oscillator,
  395.                                                 float EnvelopeTicksPerSecond, long SamplingRate,
  396.                                                 MyBoolean Stereo, MyBoolean TimeInterp, MyBoolean WaveInterp,
  397.                                                 ErrorDaemonRec* ErrorDaemon)
  398.     {
  399.         SampleTemplateRec*    Template;
  400.  
  401.         CheckPtrExistence(ErrorDaemon);
  402.         CheckPtrExistence(Oscillator);
  403.         ERROR(OscillatorGetWhatKindItIs(Oscillator) != eOscillatorSampled,PRERR(ForceAbort,
  404.             "NewSampleTemplate:  oscillator is not a sample"));
  405.  
  406.         if (SampleTemplateFreeList != NIL)
  407.             {
  408.                 Template = SampleTemplateFreeList;
  409.                 SampleTemplateFreeList = SampleTemplateFreeList->Next;
  410.             }
  411.          else
  412.             {
  413.                 Template = (SampleTemplateRec*)AllocPtrCanFail(sizeof(SampleTemplateRec),
  414.                     "SampleTemplateRec");
  415.                 if (Template == NIL)
  416.                     {
  417.                         return NIL;
  418.                     }
  419.             }
  420.         EXECUTE(Template->Next = (SampleTemplateRec*)0x81818181;)
  421.  
  422.         Template->SampleSourceSelector = NewMultisampleSample(
  423.             OscillatorGetSampleIntervalList(Oscillator));
  424.         if (Template->SampleSourceSelector == NIL)
  425.             {
  426.              FailurePoint1:
  427.                 Template->Next = SampleTemplateFreeList;
  428.                 SampleTemplateFreeList = Template;
  429.                 return NIL;
  430.             }
  431.  
  432.         Template->FinalOutputSamplingRate = SamplingRate;
  433.         Template->EnvelopeTicksPerSecond = EnvelopeTicksPerSecond;
  434.  
  435.         /* it might be better to handle divisor and multiplier separately -- we would */
  436.         /* want to do that if we were trying to guarantee that all harmonic */
  437.         /* oscillators ran in lock-step */
  438.         Template->FrequencyMultiplier = OscillatorGetFrequencyMultiplier(Oscillator)
  439.             / OscillatorGetFrequencyDivisor(Oscillator);
  440.  
  441.         Template->StereoBias = OscillatorGetStereoBias(Oscillator);
  442.         Template->TimeDisplacement = OscillatorGetTimeDisplacement(Oscillator);
  443.         Template->OverallOscillatorLoudness = OscillatorGetOutputLoudness(Oscillator);
  444.  
  445.         if (Stereo)
  446.             {
  447.                 Template->StereoPlayback = eSampleStereo;
  448.             }
  449.          else
  450.             {
  451.                 Template->StereoPlayback = eSampleMono;
  452.             }
  453.         Template->InterpolateThroughTime = TimeInterp;
  454.         Template->InterpolateAcrossWaves = WaveInterp;
  455.         Template->IncludeInFinalOutput = IncludeOscillatorInFinalOutput(Oscillator);
  456.  
  457.         /* these are just references */
  458.         Template->LoudnessEnvelopeTemplate = OscillatorGetLoudnessEnvelope(Oscillator);
  459.         Template->LoudnessLFOTemplate = OscillatorGetLoudnessLFOList(Oscillator);
  460.  
  461.         /* another reference */
  462.         Template->ErrorDaemon = ErrorDaemon;
  463.  
  464.         return Template;
  465.     }
  466.  
  467.  
  468. /* create a new sample state object. */
  469. SampleStateRec*                NewSampleState(SampleTemplateRec* Template,
  470.                                                 float FreqForMultisampling, float Accent1, float Accent2,
  471.                                                 float Accent3, float Accent4, float Loudness, float HurryUp,
  472.                                                 long* PreOriginTimeOut, float StereoPosition,
  473.                                                 float InitialFrequency)
  474.     {
  475.         SampleStateRec*            State;
  476.         long                                MaxPreOrigin;
  477.         long                                OnePreOrigin;
  478.         double                            NaturalFreqTemp;
  479.  
  480.         CheckPtrExistence(Template);
  481.         CheckValidSampleTemplate(Template);
  482.  
  483.         if (SampleStateFreeList != NIL)
  484.             {
  485.                 State = SampleStateFreeList;
  486.                 SampleStateFreeList = SampleStateFreeList->Next;
  487.             }
  488.          else
  489.             {
  490.                 State = (SampleStateRec*)AllocPtrCanFail(sizeof(SampleStateRec),
  491.                     "SampleStateRec");
  492.                 if (State == NIL)
  493.                     {
  494.                      FailurePoint1:
  495.                         return NIL;
  496.                     }
  497.             }
  498.         EXECUTE(State->Next = (SampleStateRec*)0x81818181;)
  499.  
  500.         State->Template = *Template;
  501.  
  502.         MaxPreOrigin = 0;
  503.  
  504.         Double2LongLong(0,State->SamplePosition);
  505.         /* State->SamplePositionDifferential is specified in a separate call */
  506.  
  507.         State->NoteLoudnessScaling = Loudness * Template->OverallOscillatorLoudness;
  508.  
  509.         State->SampleWasDefined = GetMultisampleReferenceSample(
  510.             Template->SampleSourceSelector,FreqForMultisampling,&(State->Data),
  511.             &(State->NumFrames),&(State->NumBits),&(State->NumChannels),&(State->Loop1Start),
  512.             &(State->Loop1End),&(State->Loop2Start),&(State->Loop2End),&(State->Loop3Start),
  513.             &(State->Loop3End),&(State->OriginPoint),&NaturalFreqTemp,&(State->SamplingRate));
  514.  
  515.         if (State->SampleWasDefined && (State->NumFrames > 0))
  516.             {
  517.                 /* copy value over */
  518.                 State->NaturalFrequency = NaturalFreqTemp;
  519.  
  520.                 /* bounds checking */
  521.                 if (State->Loop1Start < 0)
  522.                     {
  523.                         State->Loop1Start = 0;
  524.                     }
  525.                 if (State->Loop1End > State->NumFrames - 1)
  526.                     {
  527.                         State->Loop1End = State->NumFrames - 1;
  528.                     }
  529.                 if (State->Loop1End < State->Loop1Start)
  530.                     {
  531.                         State->Loop1End = State->Loop1Start;
  532.                     }
  533.                 if (State->Loop2Start < 0)
  534.                     {
  535.                         State->Loop2Start = 0;
  536.                     }
  537.                 if (State->Loop2End > State->NumFrames - 1)
  538.                     {
  539.                         State->Loop2End = State->NumFrames - 1;
  540.                     }
  541.                 if (State->Loop2End < State->Loop2Start)
  542.                     {
  543.                         State->Loop2End = State->Loop2Start;
  544.                     }
  545.                 if (State->Loop3Start < 0)
  546.                     {
  547.                         State->Loop3Start = 0;
  548.                     }
  549.                 if (State->Loop3End > State->NumFrames - 1)
  550.                     {
  551.                         State->Loop3End = State->NumFrames - 1;
  552.                     }
  553.                 if (State->Loop3End < State->Loop3Start)
  554.                     {
  555.                         State->Loop3End = State->Loop3Start;
  556.                     }
  557.  
  558.                 /* set the initial state */
  559.                 if (State->Loop1Start != State->Loop1End)
  560.                     {
  561.                         State->LoopState = eRepeatingLoop1;
  562.                         State->CurrentLoopEnd = State->Loop1End;
  563.                         State->CurrentLoopLength = State->Loop1End - State->Loop1Start;
  564.                     }
  565.                 else if (State->Loop2Start != State->Loop2End)
  566.                     {
  567.                         State->LoopState = eRepeatingLoop2;
  568.                         State->CurrentLoopEnd = State->Loop2End;
  569.                         State->CurrentLoopLength = State->Loop2End - State->Loop2Start;
  570.                     }
  571.                 else if (State->Loop3Start != State->Loop3End)
  572.                     {
  573.                         State->LoopState = eRepeatingLoop3;
  574.                         State->CurrentLoopEnd = State->Loop3End;
  575.                         State->CurrentLoopLength = State->Loop3End - State->Loop3Start;
  576.                     }
  577.                 else
  578.                     {
  579.                         State->LoopState = eNoLoop;
  580.                         State->CurrentLoopEnd = State->NumFrames;
  581.                         State->CurrentLoopLength = 0;
  582.                     }
  583.  
  584.                 /* compute how much time to wait before starting sample playback.  this */
  585.                 /* is INDEPENDENT of the envelope starting points; the envelope generator setup */
  586.                 /* handles origin alignment on its own. */
  587.                 /* this number will assume the origin starts NOW.  the fixup routine will */
  588.                 /* add some number to this so that the origin is properly determined. */
  589.                 /* if the countdown is still negative, then the sample will sound like it */
  590.                 /* is starting late.  the user can fix this by increasing the scanning gap. */
  591.                 State->PreStartCountdown = - (
  592.                     ((((float)State->OriginPoint / (InitialFrequency
  593.                         * Template->FrequencyMultiplier / State->NaturalFrequency))
  594.                         / State->SamplingRate) - Template->TimeDisplacement)
  595.                     * Template->EnvelopeTicksPerSecond + 0.5);
  596.                 if (- State->PreStartCountdown > MaxPreOrigin)
  597.                     {
  598.                         MaxPreOrigin = - State->PreStartCountdown;
  599.                     }
  600.             }
  601.          else
  602.             {
  603.                 /* no playback */
  604.                 State->LoopState = eSampleFinished;
  605.             }
  606.  
  607.         /* Template->IncludeInFinalOutput: */
  608.         /*   the routine pointer is not used for modulation */
  609.         /* State->SampleWasDefined: */
  610.         /*   if there is no sample defined for the current pitch, then we don't */
  611.         /*   bother generating any data */
  612.         /* State->NumFrames > 0: */
  613.         /*   if there is no data in the sample, then don't access the array */
  614.         if (Template->IncludeInFinalOutput && State->SampleWasDefined && (State->NumFrames > 0))
  615.             {
  616.                 if (Template->StereoPlayback == eSampleStereo) /* this is output stereo */
  617.                     {
  618.                         if (State->NumBits == eSample16bit)
  619.                             {
  620.                                 if (State->NumChannels == eSampleStereo) /* this is sample data stereo */
  621.                                     {
  622.                                         if (Template->InterpolateThroughTime)
  623.                                             {
  624.                                                 State->SampleGenSamples = Sample_StereoOut_StereoSamp_16BitIn_YesTime;
  625.                                             }
  626.                                          else
  627.                                             {
  628.                                                 State->SampleGenSamples = Sample_StereoOut_StereoSamp_16BitIn_NoTime;
  629.                                             }
  630.                                     }
  631.                                  else /* sample data mono */
  632.                                     {
  633.                                         if (Template->InterpolateThroughTime)
  634.                                             {
  635.                                                 State->SampleGenSamples = Sample_StereoOut_MonoSamp_16BitIn_YesTime;
  636.                                             }
  637.                                          else
  638.                                             {
  639.                                                 State->SampleGenSamples = Sample_StereoOut_MonoSamp_16BitIn_NoTime;
  640.                                             }
  641.                                     }
  642.                             }
  643.                          else /* output 8-bit */
  644.                             {
  645.                                 if (State->NumChannels == eSampleStereo) /* this is sample data stereo */
  646.                                     {
  647.                                         if (Template->InterpolateThroughTime)
  648.                                             {
  649.                                                 State->SampleGenSamples = Sample_StereoOut_StereoSamp_8BitIn_YesTime;
  650.                                             }
  651.                                          else
  652.                                             {
  653.                                                 State->SampleGenSamples = Sample_StereoOut_StereoSamp_8BitIn_NoTime;
  654.                                             }
  655.                                     }
  656.                                  else /* mono sample data */
  657.                                     {
  658.                                         if (Template->InterpolateThroughTime)
  659.                                             {
  660.                                                 State->SampleGenSamples = Sample_StereoOut_MonoSamp_8BitIn_YesTime;
  661.                                             }
  662.                                          else
  663.                                             {
  664.                                                 State->SampleGenSamples = Sample_StereoOut_MonoSamp_8BitIn_NoTime;
  665.                                             }
  666.                                     }
  667.                             }
  668.                     }
  669.                  else /* output mono */
  670.                     {
  671.                         if (State->NumBits == eSample16bit)
  672.                             {
  673.                                 if (State->NumChannels == eSampleStereo) /* this is sample data stereo */
  674.                                     {
  675.                                         if (Template->InterpolateThroughTime)
  676.                                             {
  677.                                                 State->SampleGenSamples = Sample_MonoOut_StereoSamp_16BitIn_YesTime;
  678.                                             }
  679.                                          else
  680.                                             {
  681.                                                 State->SampleGenSamples = Sample_MonoOut_StereoSamp_16BitIn_NoTime;
  682.                                             }
  683.                                     }
  684.                                  else /* sample data mono */
  685.                                     {
  686.                                         if (Template->InterpolateThroughTime)
  687.                                             {
  688.                                                 State->SampleGenSamples = Sample_MonoOut_MonoSamp_16BitIn_YesTime;
  689.                                             }
  690.                                          else
  691.                                             {
  692.                                                 State->SampleGenSamples = Sample_MonoOut_MonoSamp_16BitIn_NoTime;
  693.                                             }
  694.                                     }
  695.                             }
  696.                          else /* 8-bit */
  697.                             {
  698.                                 if (State->NumChannels == eSampleStereo) /* this is sample data stereo */
  699.                                     {
  700.                                         if (Template->InterpolateThroughTime)
  701.                                             {
  702.                                                 State->SampleGenSamples = Sample_MonoOut_StereoSamp_8BitIn_YesTime;
  703.                                             }
  704.                                          else
  705.                                             {
  706.                                                 State->SampleGenSamples = Sample_MonoOut_StereoSamp_8BitIn_NoTime;
  707.                                             }
  708.                                     }
  709.                                  else /* sample data mono */
  710.                                     {
  711.                                         if (Template->InterpolateThroughTime)
  712.                                             {
  713.                                                 State->SampleGenSamples = Sample_MonoOut_MonoSamp_8BitIn_YesTime;
  714.                                             }
  715.                                          else
  716.                                             {
  717.                                                 State->SampleGenSamples = Sample_MonoOut_MonoSamp_8BitIn_NoTime;
  718.                                             }
  719.                                     }
  720.                             }
  721.                     }
  722.             }
  723.          else
  724.             {
  725.                 State->SampleGenSamples = Sample_NoOutput;
  726.             }
  727.  
  728.         /* State->OverallLoudness, State->LeftLoudness, State->RightLoudness */
  729.         /* are determined by the envelope update */
  730.         StereoPosition += Template->StereoBias;
  731.         if (StereoPosition < -1)
  732.             {
  733.                 StereoPosition = -1;
  734.             }
  735.         else if (StereoPosition > 1)
  736.             {
  737.                 StereoPosition = 1;
  738.             }
  739.         State->Panning = Double2FastFixed(StereoPosition);
  740.         State->SampleLoudnessEnvelope = NewEnvelopeStateRecord(
  741.             Template->LoudnessEnvelopeTemplate,Accent1,Accent2,Accent3,Accent4,
  742.             InitialFrequency,1,HurryUp,Template->EnvelopeTicksPerSecond,&OnePreOrigin);
  743.         if (State->SampleLoudnessEnvelope == NIL)
  744.             {
  745.              FailurePoint2:
  746.                 State->Next = SampleStateFreeList;
  747.                 SampleStateFreeList = State;
  748.                 goto FailurePoint1;
  749.             }
  750.         if (OnePreOrigin > MaxPreOrigin)
  751.             {
  752.                 MaxPreOrigin = OnePreOrigin;
  753.             }
  754.         State->LoudnessLFOGenerator = NewLFOGenerator(Template->LoudnessLFOTemplate,
  755.             &OnePreOrigin,Accent1,Accent2,Accent3,Accent4,InitialFrequency,HurryUp,
  756.             Template->EnvelopeTicksPerSecond,1,1,eLFOArithDefault,FreqForMultisampling);
  757.         /* I forgot what to pass in for the last 2 parameters */
  758.         if (State->LoudnessLFOGenerator == NIL)
  759.             {
  760.              FailurePoint3:
  761.                 DisposeEnvelopeStateRecord(State->SampleLoudnessEnvelope);
  762.                 goto FailurePoint2;
  763.             }
  764.         if (OnePreOrigin > MaxPreOrigin)
  765.             {
  766.                 MaxPreOrigin = OnePreOrigin;
  767.             }
  768.  
  769.         *PreOriginTimeOut = MaxPreOrigin;
  770.         return State;
  771.     }
  772.  
  773.  
  774. /* fix up pre-origin time for the sample state object */
  775. void                                    FixUpSampleStatePreOrigin(SampleStateRec* State,
  776.                                                 long ActualPreOrigin)
  777.     {
  778.         CheckPtrExistence(State);
  779.         CheckValidSampleState(State);
  780.  
  781.         EnvelopeStateFixUpInitialDelay(State->SampleLoudnessEnvelope,ActualPreOrigin);
  782.         LFOGeneratorFixEnvelopeOrigins(State->LoudnessLFOGenerator,ActualPreOrigin);
  783.  
  784.         State->PreStartCountdown += ActualPreOrigin;
  785.     }
  786.  
  787.  
  788. /* set a new frequency for a state object.  used for portamento */
  789. /* and modulation of frequency (vibrato) */
  790. void                                    SampleStateNewFrequency(SampleStateRec* State,
  791.                                                 float NewFrequencyHertz)
  792.     {
  793.         CheckPtrExistence(State);
  794.         CheckValidSampleState(State);
  795.  
  796.         Double2LongLong((NewFrequencyHertz * State->Template.FrequencyMultiplier
  797.             / State->NaturalFrequency) / State->Template.FinalOutputSamplingRate
  798.             * State->SamplingRate,State->SamplePositionDifferential);
  799.     }
  800.  
  801.  
  802. /* send a key-up signal to one of the oscillators */
  803. void                                    SampleKeyUpSustain1(SampleStateRec* State)
  804.     {
  805.         CheckPtrExistence(State);
  806.         CheckValidSampleState(State);
  807.  
  808.         LFOGeneratorKeyUpSustain1(State->LoudnessLFOGenerator);
  809.         EnvelopeKeyUpSustain1(State->SampleLoudnessEnvelope);
  810.  
  811.         if (State->LoopState == eRepeatingLoop1)
  812.             {
  813.                 if (State->Loop2Start != State->Loop2End)
  814.                     {
  815.                         State->LoopState = eRepeatingLoop2;
  816.                         State->CurrentLoopEnd = State->Loop2End;
  817.                         State->CurrentLoopLength = State->Loop2End - State->Loop2Start;
  818.                     }
  819.                 else if (State->Loop3Start != State->Loop3End)
  820.                     {
  821.                         State->LoopState = eRepeatingLoop3;
  822.                         State->CurrentLoopEnd = State->Loop3End;
  823.                         State->CurrentLoopLength = State->Loop3End - State->Loop3Start;
  824.                     }
  825.                 else
  826.                     {
  827.                         State->LoopState = eNoLoop;
  828.                         State->CurrentLoopEnd = State->NumFrames;
  829.                         State->CurrentLoopLength = 0;
  830.                     }
  831.             }
  832.     }
  833.  
  834.  
  835. /* send a key-up signal to one of the oscillators */
  836. void                                    SampleKeyUpSustain2(SampleStateRec* State)
  837.     {
  838.         CheckPtrExistence(State);
  839.         CheckValidSampleState(State);
  840.  
  841.         LFOGeneratorKeyUpSustain2(State->LoudnessLFOGenerator);
  842.         EnvelopeKeyUpSustain2(State->SampleLoudnessEnvelope);
  843.  
  844.         if (/*(State->LoopState == eRepeatingLoop1)*/
  845.             /*||*/ (State->LoopState == eRepeatingLoop2))
  846.             {
  847.                 if (State->Loop3Start != State->Loop3End)
  848.                     {
  849.                         State->LoopState = eRepeatingLoop3;
  850.                         State->CurrentLoopEnd = State->Loop3End;
  851.                         State->CurrentLoopLength = State->Loop3End - State->Loop3Start;
  852.                     }
  853.                 else
  854.                     {
  855.                         State->LoopState = eNoLoop;
  856.                         State->CurrentLoopEnd = State->NumFrames;
  857.                         State->CurrentLoopLength = 0;
  858.                     }
  859.             }
  860.     }
  861.  
  862.  
  863. /* send a key-up signal to one of the oscillators */
  864. void                                    SampleKeyUpSustain3(SampleStateRec* State)
  865.     {
  866.         CheckPtrExistence(State);
  867.         CheckValidSampleState(State);
  868.  
  869.         LFOGeneratorKeyUpSustain3(State->LoudnessLFOGenerator);
  870.         EnvelopeKeyUpSustain3(State->SampleLoudnessEnvelope);
  871.  
  872.         if (/*(State->LoopState == eRepeatingLoop1)*/
  873.             /*|| (State->LoopState == eRepeatingLoop2)*/
  874.             /*||*/ (State->LoopState == eRepeatingLoop3))
  875.             {
  876.                 State->LoopState = eNoLoop;
  877.                 State->CurrentLoopEnd = State->NumFrames;
  878.                 State->CurrentLoopLength = 0;
  879.             }
  880.     }
  881.  
  882.  
  883. /* restart a sample oscillator.  this is used for tie continuations */
  884. void                                    RestartSampleState(SampleStateRec* State,
  885.                                                 float NewFreqMultisampling, float NewAccent1, float NewAccent2,
  886.                                                 float NewAccent3, float NewAccent4, float NewLoudness,
  887.                                                 float NewHurryUp, MyBoolean RetriggerEnvelopes,
  888.                                                 float NewStereoPosition, float NewInitialFrequency)
  889.     {
  890.         CheckPtrExistence(State);
  891.         CheckValidSampleState(State);
  892.  
  893.         NewStereoPosition += State->Template.StereoBias;
  894.         if (NewStereoPosition < -1)
  895.             {
  896.                 NewStereoPosition = -1;
  897.             }
  898.         else if (NewStereoPosition > 1)
  899.             {
  900.                 NewStereoPosition = 1;
  901.             }
  902.         State->Panning = Double2FastFixed(NewStereoPosition);
  903.  
  904.         State->NoteLoudnessScaling = NewLoudness * State->Template.OverallOscillatorLoudness;
  905.  
  906.         EnvelopeRetriggerFromOrigin(State->SampleLoudnessEnvelope,NewAccent1,NewAccent2,
  907.             NewAccent3,NewAccent4,NewInitialFrequency,1,NewHurryUp,
  908.             State->Template.EnvelopeTicksPerSecond,RetriggerEnvelopes);
  909.         LFOGeneratorRetriggerFromOrigin(State->LoudnessLFOGenerator,NewAccent1,
  910.             NewAccent2,NewAccent3,NewAccent4,NewInitialFrequency,NewHurryUp,
  911.             State->Template.EnvelopeTicksPerSecond,1,1,RetriggerEnvelopes);
  912.     }
  913.  
  914.  
  915. /* generate a sequence of samples (called for each envelope clock) */
  916. void                                    SampleGenSamples(SampleStateRec* State,
  917.                                                 long SampleCount, largefixedsigned* RawBuffer)
  918.     {
  919.         CheckPtrExistence(State);
  920.         CheckValidSampleState(State);
  921.  
  922.         if (State->PreStartCountdown > 0)
  923.             {
  924.                 return;
  925.             }
  926.         if (State->LoopState != eSampleFinished)
  927.             {
  928.                 (*State->SampleGenSamples)(State,SampleCount,RawBuffer);
  929.             }
  930.     }
  931.  
  932.  
  933. /* find out if the sample oscillator has finished */
  934. MyBoolean                            SampleIsItFinished(SampleStateRec* State)
  935.     {
  936.         CheckPtrExistence(State);
  937.         CheckValidSampleState(State);
  938.  
  939.         /* we are finished when one of the following conditions is met: */
  940.         /*  - output volume is zero AND loudness envelope is finished */
  941.         /*  - we have run off the end of the sample */
  942.         /*  - we are not generating any signal */
  943.         if (!State->SampleWasDefined)
  944.             {
  945.                 return True;
  946.             }
  947.         if (State->LoopState == eSampleFinished)
  948.             {
  949.                 return True;
  950.             }
  951.         if (IsEnvelopeAtEnd(State->SampleLoudnessEnvelope))
  952.             {
  953.                 if (State->Template.StereoPlayback == eSampleStereo)
  954.                     {
  955.                         if ((State->LeftLoudness == 0) && (State->RightLoudness == 0))
  956.                             {
  957.                                 return True;
  958.                             }
  959.                     }
  960.                  else
  961.                     {
  962.                         if (State->OverallLoudness == 0)
  963.                             {
  964.                                 return True;
  965.                             }
  966.                     }
  967.             }
  968.  
  969.         return False;
  970.     }
  971.  
  972.  
  973. /* generate a single sample (called for modulation chains) */
  974. /* OutputPlace should have 1 entry for mono output or 2 entries for stereo output */
  975. float                                    SampleGenOneSample(SampleStateRec* State,
  976.                                                 ModulationTypes* PhaseGenModulateHow,
  977.                                                 float* PhaseGenModulationScaling,
  978.                                                 float* PhaseGenModulationOrigin,
  979.                                                 float* PhaseGenOldValues,
  980.                                                 long* PhaseGenIndirectionTable,
  981.                                                 long NumberOfPhaseGenModulators,
  982.                                                 ModulationTypes* OutputModulateHow,
  983.                                                 float* OutputModulationScaling,
  984.                                                 float* OutputModulationOrigin,
  985.                                                 float* OutputOldValues,
  986.                                                 long* OutputIndirectionTable,
  987.                                                 long NumberOfOutputModulators,
  988.                                                 largefixedsigned* OutputPlace)
  989.     {
  990.         float                                ReturnValue;
  991.         LongLongRec                    FrameIndex;
  992.         signed long                    FinalLeft; /* 16-bit value */
  993.         signed long                    FinalRight; /* 16-bit value */
  994.  
  995.         CheckPtrExistence(State);
  996.         CheckValidSampleState(State);
  997.  
  998.         if (!State->SampleWasDefined || (State->LoopState == eSampleFinished)
  999.             || (State->NumFrames == 0) || (State->PreStartCountdown > 0))
  1000.             {
  1001.                 /* modulate against zero */
  1002.                 if (State->Template.StereoPlayback == eSampleStereo)
  1003.                     {
  1004.                         OutputPlace[0] += double2largefixed(ApplyModulation(0,OutputModulateHow,
  1005.                             OutputModulationScaling,OutputModulationOrigin,OutputOldValues,
  1006.                             OutputIndirectionTable,NumberOfOutputModulators));
  1007.                         OutputPlace[1] += double2largefixed(ApplyModulation(0,OutputModulateHow,
  1008.                             OutputModulationScaling,OutputModulationOrigin,OutputOldValues,
  1009.                             OutputIndirectionTable,NumberOfOutputModulators));
  1010.                     }
  1011.                  else
  1012.                     {
  1013.                         OutputPlace[0] += double2largefixed(ApplyModulation(0,OutputModulateHow,
  1014.                             OutputModulationScaling,OutputModulationOrigin,OutputOldValues,
  1015.                             OutputIndirectionTable,NumberOfOutputModulators));
  1016.                     }
  1017.                 return 0;
  1018.             }
  1019.  
  1020.         /* generate the sample position */
  1021.         /* we need to normalize the sample position to make modulation characteristics */
  1022.         /* independent on sampling rate.  this is done by normalizing the sample so that */
  1023.         /* a displacement of 1 corresponds to 1 second of evaluation time. */
  1024.         Double2LongLong(ApplyModulation(LongLong2Double(State->SamplePosition)
  1025.             / State->SamplingRate,PhaseGenModulateHow,PhaseGenModulationScaling,
  1026.             PhaseGenModulationOrigin,PhaseGenOldValues,PhaseGenIndirectionTable,
  1027.             NumberOfPhaseGenModulators) * State->SamplingRate,FrameIndex);
  1028.         /* ugh, phase modulation of a sample is nasty. */
  1029.         if (LongLongHighHalf(FrameIndex) < 0)
  1030.             {
  1031.                 LongLongSetHighHalf(FrameIndex,0);
  1032.             }
  1033.         if (LongLongHighHalf(FrameIndex) > State->NumFrames - 1)
  1034.             {
  1035.                 LongLongSetHighHalf(FrameIndex,State->NumFrames - 1);
  1036.             }
  1037.  
  1038.         if (State->NumChannels == eSampleStereo)
  1039.             {
  1040.                 /* stereo sample */
  1041.                 if (State->NumBits == eSample16bit)
  1042.                     {
  1043.                         /* stereo sample, 16 bit */
  1044.                         if (State->Template.InterpolateThroughTime)
  1045.                             {
  1046.                                 signed short*                SampleData;
  1047.                                 FastFixedType                LeftWeight;
  1048.                                 long                                ArraySubscript;
  1049.                                 signed long                    LeftValue;
  1050.                                 signed long                    RightValue;
  1051.  
  1052.                                 /* stereo sample, 16 bit, interpolate */
  1053.                                 SampleData = (signed short*)State->Data;
  1054.                                 /* L+F(R-L) */
  1055.                                 LeftWeight = LongLongLowHalf(FrameIndex) >> (32 - FASTFIXEDPRECISION);
  1056.                                 ArraySubscript = LongLongHighHalf(FrameIndex);
  1057.                                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 0)]),
  1058.                                     sizeof(SampleData[2 * (ArraySubscript + 0)]));
  1059.                                 LeftValue = SampleData[2 * (ArraySubscript + 0)];
  1060.                                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 1)]),
  1061.                                     sizeof(SampleData[2 * (ArraySubscript + 1)]));
  1062.                                 RightValue = SampleData[2 * (ArraySubscript + 1)];
  1063.                                 FinalLeft = LeftValue + ((LeftWeight * (RightValue - LeftValue)) >> 15);
  1064.                                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 0) + 1]),
  1065.                                     sizeof(SampleData[2 * (ArraySubscript + 0) + 1]));
  1066.                                 LeftValue = SampleData[2 * (ArraySubscript + 0) + 1];
  1067.                                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 1) + 1]),
  1068.                                     sizeof(SampleData[2 * (ArraySubscript + 1) + 1]));
  1069.                                 RightValue = SampleData[2 * (ArraySubscript + 1) + 1];
  1070.                                 FinalRight = LeftValue + ((LeftWeight * (RightValue - LeftValue)) >> 15);
  1071.                             }
  1072.                          else
  1073.                             {
  1074.                                 signed short*                SampleData;
  1075.  
  1076.                                 /* stereo output, stereo sample, 16 bit, truncate */
  1077.                                 SampleData = (signed short*)State->Data;
  1078.                                 PRNGCHK(SampleData,&(SampleData[2 * LongLongHighHalf(
  1079.                                     FrameIndex) + 0]),sizeof(SampleData[2
  1080.                                     * LongLongHighHalf(FrameIndex) + 0]));
  1081.                                 FinalLeft = SampleData[2 * LongLongHighHalf(FrameIndex) + 0];
  1082.                                 PRNGCHK(SampleData,&(SampleData[2 * LongLongHighHalf(
  1083.                                     FrameIndex) + 1]),sizeof(SampleData[2
  1084.                                     * LongLongHighHalf(FrameIndex) + 1]));
  1085.                                 FinalRight = SampleData[2 * LongLongHighHalf(FrameIndex) + 1];
  1086.                             }
  1087.                     }
  1088.                  else
  1089.                     {
  1090.                         /* stereo sample, 8 bit */
  1091.                         if (State->Template.InterpolateThroughTime)
  1092.                             {
  1093.                                 signed char*                SampleData;
  1094.                                 FastFixedType                LeftWeight;
  1095.                                 long                                ArraySubscript;
  1096.                                 signed long                    LeftValue;
  1097.                                 signed long                    RightValue;
  1098.  
  1099.                                 /* stereo sample, 8 bit, interpolate */
  1100.                                 SampleData = (signed char*)State->Data;
  1101.                                 /* L+F(R-L) */
  1102.                                 LeftWeight = LongLongLowHalf(FrameIndex) >> (32 - FASTFIXEDPRECISION);
  1103.                                 ArraySubscript = LongLongHighHalf(FrameIndex);
  1104.                                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 0)]),
  1105.                                     sizeof(SampleData[2 * (ArraySubscript + 0)]));
  1106.                                 LeftValue = ((signed long)SampleData[2 * (ArraySubscript + 0)]) << 8; /* convert to 16-bit */
  1107.                                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 1)]),
  1108.                                     sizeof(SampleData[2 * (ArraySubscript + 1)]));
  1109.                                 RightValue = ((signed long)SampleData[2 * (ArraySubscript + 1)]) << 8; /* to 16-bit */
  1110.                                 FinalLeft = LeftValue + ((LeftWeight * (RightValue - LeftValue)) >> 15);
  1111.                                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 0) + 1]),
  1112.                                     sizeof(SampleData[2 * (ArraySubscript + 0) + 1]));
  1113.                                 LeftValue = ((signed long)SampleData[2 * (ArraySubscript + 0) + 1]) << 8; /* convert to 16-bit */
  1114.                                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 1) + 1]),
  1115.                                     sizeof(SampleData[2 * (ArraySubscript + 1) + 1]));
  1116.                                 RightValue = ((signed long)SampleData[2 * (ArraySubscript + 1) + 1]) << 8; /* to 16-bit */
  1117.                                 FinalRight = LeftValue + ((LeftWeight * (RightValue - LeftValue)) >> 15);
  1118.                             }
  1119.                          else
  1120.                             {
  1121.                                 signed char*                SampleData;
  1122.  
  1123.                                 /* stereo sample, 8 bit, truncate */
  1124.                                 SampleData = (signed char*)State->Data;
  1125.                                 PRNGCHK(SampleData,&(SampleData[2 * LongLongHighHalf(
  1126.                                     FrameIndex) + 0]),sizeof(SampleData[2
  1127.                                     * LongLongHighHalf(FrameIndex) + 0]));
  1128.                                 FinalLeft = SampleData[2 * LongLongHighHalf(FrameIndex) + 0];
  1129.                                 PRNGCHK(SampleData,&(SampleData[2 * LongLongHighHalf(
  1130.                                     FrameIndex) + 1]),sizeof(SampleData[2
  1131.                                     * LongLongHighHalf(FrameIndex) + 1]));
  1132.                                 FinalRight = SampleData[2 * LongLongHighHalf(FrameIndex) + 1];
  1133.                             }
  1134.                     }
  1135.             }
  1136.          else
  1137.             {
  1138.                 /* mono sample */
  1139.                 if (State->NumBits == eSample16bit)
  1140.                     {
  1141.                         /* mono sample, 16 bit */
  1142.                         if (State->Template.InterpolateThroughTime)
  1143.                             {
  1144.                                 signed short*                SampleData;
  1145.                                 FastFixedType                LeftWeight;
  1146.                                 long                                ArraySubscript;
  1147.                                 signed long                    LeftValue;
  1148.                                 signed long                    RightValue;
  1149.  
  1150.                                 /* mono sample, 16 bit, interpolate */
  1151.                                 SampleData = (signed short*)State->Data;
  1152.                                 /* L+F(R-L) */
  1153.                                 LeftWeight = LongLongLowHalf(FrameIndex) >> (32 - FASTFIXEDPRECISION);
  1154.                                 ArraySubscript = LongLongHighHalf(FrameIndex);
  1155.                                 PRNGCHK(SampleData,&(SampleData[ArraySubscript]),
  1156.                                     sizeof(SampleData[ArraySubscript]));
  1157.                                 LeftValue = SampleData[ArraySubscript];
  1158.                                 PRNGCHK(SampleData,&(SampleData[ArraySubscript + 1]),
  1159.                                     sizeof(SampleData[ArraySubscript + 1]));
  1160.                                 RightValue = SampleData[ArraySubscript + 1];
  1161.                                 FinalLeft = LeftValue + ((LeftWeight * (RightValue - LeftValue)) >> 15);
  1162.                                 FinalRight = FinalLeft;
  1163.                             }
  1164.                          else
  1165.                             {
  1166.                                 signed short*                SampleData;
  1167.  
  1168.                                 /* mono sample, 16 bit, truncate */
  1169.                                 SampleData = (signed short*)State->Data;
  1170.                                 PRNGCHK(SampleData,&(SampleData[LongLongHighHalf(
  1171.                                     FrameIndex)]),sizeof(SampleData[LongLongHighHalf(
  1172.                                     FrameIndex)]));
  1173.                                 FinalLeft = SampleData[LongLongHighHalf(FrameIndex)];
  1174.                                 FinalRight = FinalLeft;
  1175.                             }
  1176.                     }
  1177.                  else
  1178.                     {
  1179.                         /* mono sample, 8 bit */
  1180.                         if (State->Template.InterpolateThroughTime)
  1181.                             {
  1182.                                 signed char*                SampleData;
  1183.                                 FastFixedType                LeftWeight;
  1184.                                 long                                ArraySubscript;
  1185.                                 signed long                    LeftValue;
  1186.                                 signed long                    RightValue;
  1187.  
  1188.                                 /* mono sample, 8 bit, interpolate */
  1189.                                 SampleData = (signed char*)State->Data;
  1190.                                 /* L+F(R-L) */
  1191.                                 LeftWeight = LongLongLowHalf(FrameIndex) >> (32 - FASTFIXEDPRECISION);
  1192.                                 ArraySubscript = LongLongHighHalf(FrameIndex);
  1193.                                 PRNGCHK(SampleData,&(SampleData[ArraySubscript]),
  1194.                                     sizeof(SampleData[ArraySubscript]));
  1195.                                 LeftValue = ((signed long)SampleData[ArraySubscript]) << 8; /* convert to 16-bit */
  1196.                                 PRNGCHK(SampleData,&(SampleData[ArraySubscript + 1]),
  1197.                                     sizeof(SampleData[ArraySubscript + 1]));
  1198.                                 RightValue = ((signed long)SampleData[ArraySubscript + 1]) << 8; /* to 16-bit */
  1199.                                 FinalLeft = LeftValue + ((LeftWeight * (RightValue - LeftValue)) >> 15);
  1200.                                 FinalRight = FinalLeft;
  1201.                             }
  1202.                          else
  1203.                             {
  1204.                                 signed char*                SampleData;
  1205.  
  1206.                                 /* stereo output, mono sample, 8 bit, truncate */
  1207.                                 SampleData = (signed char*)State->Data;
  1208.                                 PRNGCHK(SampleData,&(SampleData[LongLongHighHalf(
  1209.                                     FrameIndex)]),sizeof(SampleData[LongLongHighHalf(
  1210.                                         FrameIndex)]));
  1211.                                 FinalLeft = SampleData[LongLongHighHalf(FrameIndex)];
  1212.                                 FinalRight = FinalLeft;
  1213.                             }
  1214.                     }
  1215.             }
  1216.  
  1217.         if (State->Template.StereoPlayback == eSampleStereo)
  1218.             {
  1219.                 ReturnValue = (((float)((FinalLeft + FinalRight) / 2)) / MAX16BIT)
  1220.                     * ((FastFixed2Float(State->LeftLoudness)
  1221.                     + FastFixed2Float(State->RightLoudness)) / 2);
  1222.                 if (State->Template.IncludeInFinalOutput)
  1223.                     {
  1224.                         OutputPlace[0] += double2largefixed(ApplyModulation(largefixed2single(
  1225.                             FastFixedTimes16BitTo24Bit((signed long)(State->LeftLoudness
  1226.                             * State->NoteLoudnessScaling),FinalLeft)),OutputModulateHow,
  1227.                             OutputModulationScaling,OutputModulationOrigin,OutputOldValues,
  1228.                             OutputIndirectionTable,NumberOfOutputModulators));;
  1229.                         OutputPlace[1] += double2largefixed(ApplyModulation(largefixed2single(
  1230.                             FastFixedTimes16BitTo24Bit((signed long)(State->RightLoudness
  1231.                             * State->NoteLoudnessScaling),FinalRight)),OutputModulateHow,
  1232.                             OutputModulationScaling,OutputModulationOrigin,OutputOldValues,
  1233.                             OutputIndirectionTable,NumberOfOutputModulators));
  1234.                     }
  1235.             }
  1236.          else
  1237.             {
  1238.                 ReturnValue = (((float)((FinalLeft + FinalRight) / 2)) / MAX16BIT)
  1239.                     * FastFixed2Float(State->OverallLoudness);
  1240.                 if (State->Template.IncludeInFinalOutput)
  1241.                     {
  1242.                         OutputPlace[0] += double2largefixed(ApplyModulation(largefixed2single(
  1243.                             FastFixedTimes16BitTo24Bit((signed long)(State->OverallLoudness
  1244.                             * State->NoteLoudnessScaling),((FinalLeft + FinalRight) / 2))),
  1245.                             OutputModulateHow,OutputModulationScaling,OutputModulationOrigin,
  1246.                             OutputOldValues,OutputIndirectionTable,NumberOfOutputModulators));
  1247.                     }
  1248.             }
  1249.  
  1250.         LongLongAdd(&State->SamplePosition,&State->SamplePositionDifferential);
  1251.      CheapDoLoop:
  1252.         if (LongLongHighHalf(State->SamplePosition) >= State->CurrentLoopEnd)
  1253.             {
  1254.                 if (State->LoopState != eNoLoop)
  1255.                     {
  1256.                         /* handle loop */
  1257.                         LongLongSetHighHalf(State->SamplePosition,LongLongHighHalf(
  1258.                             State->SamplePosition) - State->CurrentLoopLength);
  1259.                         goto CheapDoLoop;
  1260.                     }
  1261.                  else
  1262.                     {
  1263.                         /* end of sample -- terminate */
  1264.                         State->LoopState = eSampleFinished;
  1265.                         goto BreakLoopPoint;
  1266.                     }
  1267.             }
  1268.      BreakLoopPoint:
  1269.         ;
  1270.  
  1271.         return ReturnValue;
  1272.     }
  1273.  
  1274.  
  1275. static void                        Sample_MonoOut_MonoSamp_8BitIn_NoTime(SampleStateRec* State,
  1276.                                                 long SampleCount, largefixedsigned* RawBuffer)
  1277.     {
  1278.         LongLongRec                    LocalSamplePosition;
  1279.         LongLongRec                    LocalSamplePositionDifferential;
  1280.         long                                LocalCurrentLoopEnd;
  1281.         FastFixedType                LocalOverallLoudness;
  1282.         signed char*                SampleData;
  1283.  
  1284.         LocalOverallLoudness = State->OverallLoudness;
  1285.         LocalSamplePosition = State->SamplePosition;
  1286.         LocalSamplePositionDifferential = State->SamplePositionDifferential;
  1287.         LocalCurrentLoopEnd = State->CurrentLoopEnd;
  1288.         SampleData = (signed char*)State->Data;
  1289.  
  1290.         while (SampleCount > 0)
  1291.             {
  1292.                 PRNGCHK(SampleData,&(SampleData[LongLongHighHalf(LocalSamplePosition)]),
  1293.                     sizeof(SampleData[LongLongHighHalf(LocalSamplePosition)]));
  1294.                 *(RawBuffer++) += FastFixedTimes8BitTo24Bit(LocalOverallLoudness,
  1295.                     SampleData[LongLongHighHalf(LocalSamplePosition)]);
  1296.                 LongLongAdd(&LocalSamplePosition,&LocalSamplePositionDifferential);
  1297.              CheapDoLoop:
  1298.                 if (LongLongHighHalf(LocalSamplePosition) >= LocalCurrentLoopEnd)
  1299.                     {
  1300.                         if (State->LoopState != eNoLoop)
  1301.                             {
  1302.                                 /* handle loop */
  1303.                                 LongLongSetHighHalf(LocalSamplePosition,LongLongHighHalf(
  1304.                                     LocalSamplePosition) - State->CurrentLoopLength);
  1305.                                 goto CheapDoLoop;
  1306.                             }
  1307.                          else
  1308.                             {
  1309.                                 /* end of sample -- terminate */
  1310.                                 State->LoopState = eSampleFinished;
  1311.                                 goto BreakLoopPoint;
  1312.                             }
  1313.                     }
  1314.                 SampleCount -= 1;
  1315.             }
  1316.      BreakLoopPoint:
  1317.         ;
  1318.  
  1319.         State->SamplePosition = LocalSamplePosition;
  1320.     }
  1321.  
  1322.  
  1323. static void                        Sample_StereoOut_MonoSamp_8BitIn_NoTime(SampleStateRec* State,
  1324.                                                 long SampleCount, largefixedsigned* RawBuffer)
  1325.     {
  1326.         LongLongRec                    LocalSamplePosition;
  1327.         LongLongRec                    LocalSamplePositionDifferential;
  1328.         long                                LocalCurrentLoopEnd;
  1329.         FastFixedType                LocalLeftLoudness;
  1330.         FastFixedType                LocalRightLoudness;
  1331.         signed char*                SampleData;
  1332.  
  1333.         LocalLeftLoudness = State->LeftLoudness;
  1334.         LocalRightLoudness = State->RightLoudness;
  1335.         LocalSamplePosition = State->SamplePosition;
  1336.         LocalSamplePositionDifferential = State->SamplePositionDifferential;
  1337.         LocalCurrentLoopEnd = State->CurrentLoopEnd;
  1338.         SampleData = (signed char*)State->Data;
  1339.  
  1340.         while (SampleCount > 0)
  1341.             {
  1342.                 signed long                    SamplePoint;
  1343.  
  1344.                 PRNGCHK(SampleData,&(SampleData[LongLongHighHalf(LocalSamplePosition)]),
  1345.                     sizeof(SampleData[LongLongHighHalf(LocalSamplePosition)]));
  1346.                 SamplePoint = SampleData[LongLongHighHalf(LocalSamplePosition)];
  1347.                 *(RawBuffer++) += FastFixedTimes8BitTo24Bit(LocalLeftLoudness,SamplePoint);
  1348.                 *(RawBuffer++) += FastFixedTimes8BitTo24Bit(LocalRightLoudness,SamplePoint);
  1349.                 LongLongAdd(&LocalSamplePosition,&LocalSamplePositionDifferential);
  1350.              CheapDoLoop:
  1351.                 if (LongLongHighHalf(LocalSamplePosition) >= LocalCurrentLoopEnd)
  1352.                     {
  1353.                         if (State->LoopState != eNoLoop)
  1354.                             {
  1355.                                 /* handle loop */
  1356.                                 LongLongSetHighHalf(LocalSamplePosition,LongLongHighHalf(
  1357.                                     LocalSamplePosition) - State->CurrentLoopLength);
  1358.                                 goto CheapDoLoop;
  1359.                             }
  1360.                          else
  1361.                             {
  1362.                                 /* end of sample -- terminate */
  1363.                                 State->LoopState = eSampleFinished;
  1364.                                 goto BreakLoopPoint;
  1365.                             }
  1366.                     }
  1367.                 SampleCount -= 1;
  1368.             }
  1369.      BreakLoopPoint:
  1370.         ;
  1371.  
  1372.         State->SamplePosition = LocalSamplePosition;
  1373.     }
  1374.  
  1375.  
  1376. static void                        Sample_MonoOut_StereoSamp_8BitIn_NoTime(SampleStateRec* State,
  1377.                                                 long SampleCount, largefixedsigned* RawBuffer)
  1378.     {
  1379.         LongLongRec                    LocalSamplePosition;
  1380.         LongLongRec                    LocalSamplePositionDifferential;
  1381.         long                                LocalCurrentLoopEnd;
  1382.         FastFixedType                LocalOverallLoudness;
  1383.         signed char*                SampleData;
  1384.  
  1385.         LocalOverallLoudness = State->OverallLoudness;
  1386.         LocalSamplePosition = State->SamplePosition;
  1387.         LocalSamplePositionDifferential = State->SamplePositionDifferential;
  1388.         LocalCurrentLoopEnd = State->CurrentLoopEnd;
  1389.         SampleData = (signed char*)State->Data;
  1390.  
  1391.         while (SampleCount > 0)
  1392.             {
  1393.                 PRNGCHK(SampleData,&(SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 0]),
  1394.                     sizeof(SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 0]));
  1395.                 PRNGCHK(SampleData,&(SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 1]),
  1396.                     sizeof(SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 1]));
  1397.                 *(RawBuffer++) += FastFixedTimes8BitTo24Bit(LocalOverallLoudness,
  1398.                     ((signed long)SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 0]
  1399.                     + (signed long)SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 1]) >> 1);
  1400.                 LongLongAdd(&LocalSamplePosition,&LocalSamplePositionDifferential);
  1401.              CheapDoLoop:
  1402.                 if (LongLongHighHalf(LocalSamplePosition) >= LocalCurrentLoopEnd)
  1403.                     {
  1404.                         if (State->LoopState != eNoLoop)
  1405.                             {
  1406.                                 /* handle loop */
  1407.                                 LongLongSetHighHalf(LocalSamplePosition,LongLongHighHalf(
  1408.                                     LocalSamplePosition) - State->CurrentLoopLength);
  1409.                                 goto CheapDoLoop;
  1410.                             }
  1411.                          else
  1412.                             {
  1413.                                 /* end of sample -- terminate */
  1414.                                 State->LoopState = eSampleFinished;
  1415.                                 goto BreakLoopPoint;
  1416.                             }
  1417.                     }
  1418.                 SampleCount -= 1;
  1419.             }
  1420.      BreakLoopPoint:
  1421.         ;
  1422.  
  1423.         State->SamplePosition = LocalSamplePosition;
  1424.     }
  1425.  
  1426.  
  1427. static void                        Sample_StereoOut_StereoSamp_8BitIn_NoTime(SampleStateRec* State,
  1428.                                                 long SampleCount, largefixedsigned* RawBuffer)
  1429.     {
  1430.         LongLongRec                    LocalSamplePosition;
  1431.         LongLongRec                    LocalSamplePositionDifferential;
  1432.         long                                LocalCurrentLoopEnd;
  1433.         FastFixedType                LocalLeftLoudness;
  1434.         FastFixedType                LocalRightLoudness;
  1435.         signed char*                SampleData;
  1436.  
  1437.         LocalLeftLoudness = State->LeftLoudness;
  1438.         LocalRightLoudness = State->RightLoudness;
  1439.         LocalSamplePosition = State->SamplePosition;
  1440.         LocalSamplePositionDifferential = State->SamplePositionDifferential;
  1441.         LocalCurrentLoopEnd = State->CurrentLoopEnd;
  1442.         SampleData = (signed char*)State->Data;
  1443.  
  1444.         while (SampleCount > 0)
  1445.             {
  1446.                 PRNGCHK(SampleData,&(SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 0]),
  1447.                     sizeof(SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 0]));
  1448.                 *(RawBuffer++) += FastFixedTimes8BitTo24Bit(LocalLeftLoudness,
  1449.                     (signed long)SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 0]);
  1450.                 PRNGCHK(SampleData,&(SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 1]),
  1451.                     sizeof(SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 1]));
  1452.                 *(RawBuffer++) += FastFixedTimes8BitTo24Bit(LocalRightLoudness,
  1453.                     (signed long)SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 1]);
  1454.                 LongLongAdd(&LocalSamplePosition,&LocalSamplePositionDifferential);
  1455.              CheapDoLoop:
  1456.                 if (LongLongHighHalf(LocalSamplePosition) >= LocalCurrentLoopEnd)
  1457.                     {
  1458.                         if (State->LoopState != eNoLoop)
  1459.                             {
  1460.                                 /* handle loop */
  1461.                                 LongLongSetHighHalf(LocalSamplePosition,LongLongHighHalf(
  1462.                                     LocalSamplePosition) - State->CurrentLoopLength);
  1463.                                 goto CheapDoLoop;
  1464.                             }
  1465.                          else
  1466.                             {
  1467.                                 /* end of sample -- terminate */
  1468.                                 State->LoopState = eSampleFinished;
  1469.                                 goto BreakLoopPoint;
  1470.                             }
  1471.                     }
  1472.                 SampleCount -= 1;
  1473.             }
  1474.      BreakLoopPoint:
  1475.         ;
  1476.  
  1477.         State->SamplePosition = LocalSamplePosition;
  1478.     }
  1479.  
  1480.  
  1481. static void                        Sample_MonoOut_MonoSamp_16BitIn_NoTime(SampleStateRec* State,
  1482.                                                 long SampleCount, largefixedsigned* RawBuffer)
  1483.     {
  1484.         LongLongRec                    LocalSamplePosition;
  1485.         LongLongRec                    LocalSamplePositionDifferential;
  1486.         long                                LocalCurrentLoopEnd;
  1487.         FastFixedType                LocalOverallLoudness;
  1488.         signed short*                SampleData;
  1489.  
  1490.         LocalOverallLoudness = State->OverallLoudness;
  1491.         LocalSamplePosition = State->SamplePosition;
  1492.         LocalSamplePositionDifferential = State->SamplePositionDifferential;
  1493.         LocalCurrentLoopEnd = State->CurrentLoopEnd;
  1494.         SampleData = (signed short*)State->Data;
  1495.  
  1496.         while (SampleCount > 0)
  1497.             {
  1498.                 PRNGCHK(SampleData,&(SampleData[LongLongHighHalf(LocalSamplePosition)]),
  1499.                     sizeof(SampleData[LongLongHighHalf(LocalSamplePosition)]));
  1500.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalOverallLoudness,
  1501.                     SampleData[LongLongHighHalf(LocalSamplePosition)]);
  1502.                 LongLongAdd(&LocalSamplePosition,&LocalSamplePositionDifferential);
  1503.              CheapDoLoop:
  1504.                 if (LongLongHighHalf(LocalSamplePosition) >= LocalCurrentLoopEnd)
  1505.                     {
  1506.                         if (State->LoopState != eNoLoop)
  1507.                             {
  1508.                                 /* handle loop */
  1509.                                 LongLongSetHighHalf(LocalSamplePosition,LongLongHighHalf(
  1510.                                     LocalSamplePosition) - State->CurrentLoopLength);
  1511.                                 goto CheapDoLoop;
  1512.                             }
  1513.                          else
  1514.                             {
  1515.                                 /* end of sample -- terminate */
  1516.                                 State->LoopState = eSampleFinished;
  1517.                                 goto BreakLoopPoint;
  1518.                             }
  1519.                     }
  1520.                 SampleCount -= 1;
  1521.             }
  1522.      BreakLoopPoint:
  1523.         ;
  1524.  
  1525.         State->SamplePosition = LocalSamplePosition;
  1526.     }
  1527.  
  1528.  
  1529. static void                        Sample_StereoOut_MonoSamp_16BitIn_NoTime(SampleStateRec* State,
  1530.                                                 long SampleCount, largefixedsigned* RawBuffer)
  1531.     {
  1532.         LongLongRec                    LocalSamplePosition;
  1533.         LongLongRec                    LocalSamplePositionDifferential;
  1534.         long                                LocalCurrentLoopEnd;
  1535.         FastFixedType                LocalLeftLoudness;
  1536.         FastFixedType                LocalRightLoudness;
  1537.         signed short*                SampleData;
  1538.  
  1539.         LocalLeftLoudness = State->LeftLoudness;
  1540.         LocalRightLoudness = State->RightLoudness;
  1541.         LocalSamplePosition = State->SamplePosition;
  1542.         LocalSamplePositionDifferential = State->SamplePositionDifferential;
  1543.         LocalCurrentLoopEnd = State->CurrentLoopEnd;
  1544.         SampleData = (signed short*)State->Data;
  1545.  
  1546.         while (SampleCount > 0)
  1547.             {
  1548.                 signed long                    SamplePoint;
  1549.  
  1550.                 PRNGCHK(SampleData,&(SampleData[LongLongHighHalf(LocalSamplePosition)]),
  1551.                     sizeof(SampleData[LongLongHighHalf(LocalSamplePosition)]));
  1552.                 SamplePoint = SampleData[LongLongHighHalf(LocalSamplePosition)];
  1553.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalLeftLoudness,SamplePoint);
  1554.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalRightLoudness,SamplePoint);
  1555.                 LongLongAdd(&LocalSamplePosition,&LocalSamplePositionDifferential);
  1556.              CheapDoLoop:
  1557.                 if (LongLongHighHalf(LocalSamplePosition) >= LocalCurrentLoopEnd)
  1558.                     {
  1559.                         if (State->LoopState != eNoLoop)
  1560.                             {
  1561.                                 /* handle loop */
  1562.                                 LongLongSetHighHalf(LocalSamplePosition,LongLongHighHalf(
  1563.                                     LocalSamplePosition) - State->CurrentLoopLength);
  1564.                                 goto CheapDoLoop;
  1565.                             }
  1566.                          else
  1567.                             {
  1568.                                 /* end of sample -- terminate */
  1569.                                 State->LoopState = eSampleFinished;
  1570.                                 goto BreakLoopPoint;
  1571.                             }
  1572.                     }
  1573.                 SampleCount -= 1;
  1574.             }
  1575.      BreakLoopPoint:
  1576.         ;
  1577.  
  1578.         State->SamplePosition = LocalSamplePosition;
  1579.     }
  1580.  
  1581.  
  1582. static void                        Sample_MonoOut_StereoSamp_16BitIn_NoTime(SampleStateRec* State,
  1583.                                                 long SampleCount, largefixedsigned* RawBuffer)
  1584.     {
  1585.         LongLongRec                    LocalSamplePosition;
  1586.         LongLongRec                    LocalSamplePositionDifferential;
  1587.         long                                LocalCurrentLoopEnd;
  1588.         FastFixedType                LocalOverallLoudness;
  1589.         signed short*                SampleData;
  1590.  
  1591.         LocalOverallLoudness = State->OverallLoudness;
  1592.         LocalSamplePosition = State->SamplePosition;
  1593.         LocalSamplePositionDifferential = State->SamplePositionDifferential;
  1594.         LocalCurrentLoopEnd = State->CurrentLoopEnd;
  1595.         SampleData = (signed short*)State->Data;
  1596.  
  1597.         while (SampleCount > 0)
  1598.             {
  1599.                 PRNGCHK(SampleData,&(SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 0]),
  1600.                     sizeof(SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 0]));
  1601.                 PRNGCHK(SampleData,&(SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 1]),
  1602.                     sizeof(SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 1]));
  1603.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalOverallLoudness,
  1604.                     ((signed long)SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 0]
  1605.                     + (signed long)SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 1]) >> 1);
  1606.                 LongLongAdd(&LocalSamplePosition,&LocalSamplePositionDifferential);
  1607.              CheapDoLoop:
  1608.                 if (LongLongHighHalf(LocalSamplePosition) >= LocalCurrentLoopEnd)
  1609.                     {
  1610.                         if (State->LoopState != eNoLoop)
  1611.                             {
  1612.                                 /* handle loop */
  1613.                                 LongLongSetHighHalf(LocalSamplePosition,LongLongHighHalf(
  1614.                                     LocalSamplePosition) - State->CurrentLoopLength);
  1615.                                 goto CheapDoLoop;
  1616.                             }
  1617.                          else
  1618.                             {
  1619.                                 /* end of sample -- terminate */
  1620.                                 State->LoopState = eSampleFinished;
  1621.                                 goto BreakLoopPoint;
  1622.                             }
  1623.                     }
  1624.                 SampleCount -= 1;
  1625.             }
  1626.      BreakLoopPoint:
  1627.         ;
  1628.  
  1629.         State->SamplePosition = LocalSamplePosition;
  1630.     }
  1631.  
  1632.  
  1633. static void                        Sample_StereoOut_StereoSamp_16BitIn_NoTime(SampleStateRec* State,
  1634.                                                 long SampleCount, largefixedsigned* RawBuffer)
  1635.     {
  1636.         LongLongRec                    LocalSamplePosition;
  1637.         LongLongRec                    LocalSamplePositionDifferential;
  1638.         long                                LocalCurrentLoopEnd;
  1639.         FastFixedType                LocalLeftLoudness;
  1640.         FastFixedType                LocalRightLoudness;
  1641.         signed short*                SampleData;
  1642.  
  1643.         LocalLeftLoudness = State->LeftLoudness;
  1644.         LocalRightLoudness = State->RightLoudness;
  1645.         LocalSamplePosition = State->SamplePosition;
  1646.         LocalSamplePositionDifferential = State->SamplePositionDifferential;
  1647.         LocalCurrentLoopEnd = State->CurrentLoopEnd;
  1648.         SampleData = (signed short*)State->Data;
  1649.  
  1650.         while (SampleCount > 0)
  1651.             {
  1652.                 PRNGCHK(SampleData,&(SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 0]),
  1653.                     sizeof(SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 0]));
  1654.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalLeftLoudness,
  1655.                     (signed long)SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 0]);
  1656.                 PRNGCHK(SampleData,&(SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 1]),
  1657.                     sizeof(SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 1]));
  1658.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalRightLoudness,
  1659.                     (signed long)SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 1]);
  1660.                 LongLongAdd(&LocalSamplePosition,&LocalSamplePositionDifferential);
  1661.              CheapDoLoop:
  1662.                 if (LongLongHighHalf(LocalSamplePosition) >= LocalCurrentLoopEnd)
  1663.                     {
  1664.                         if (State->LoopState != eNoLoop)
  1665.                             {
  1666.                                 /* handle loop */
  1667.                                 LongLongSetHighHalf(LocalSamplePosition,LongLongHighHalf(
  1668.                                     LocalSamplePosition) - State->CurrentLoopLength);
  1669.                                 goto CheapDoLoop;
  1670.                             }
  1671.                          else
  1672.                             {
  1673.                                 /* end of sample -- terminate */
  1674.                                 State->LoopState = eSampleFinished;
  1675.                                 goto BreakLoopPoint;
  1676.                             }
  1677.                     }
  1678.                 SampleCount -= 1;
  1679.             }
  1680.      BreakLoopPoint:
  1681.         ;
  1682.  
  1683.         State->SamplePosition = LocalSamplePosition;
  1684.     }
  1685.  
  1686.  
  1687. static void                        Sample_MonoOut_MonoSamp_8BitIn_YesTime(SampleStateRec* State,
  1688.                                                 long SampleCount, largefixedsigned* RawBuffer)
  1689.     {
  1690.         LongLongRec                    LocalSamplePosition;
  1691.         LongLongRec                    LocalSamplePositionDifferential;
  1692.         long                                LocalCurrentLoopEnd;
  1693.         FastFixedType                LocalOverallLoudness;
  1694.         signed char*                SampleData;
  1695.  
  1696.         LocalOverallLoudness = State->OverallLoudness;
  1697.         LocalSamplePosition = State->SamplePosition;
  1698.         LocalSamplePositionDifferential = State->SamplePositionDifferential;
  1699.         LocalCurrentLoopEnd = State->CurrentLoopEnd;
  1700.         SampleData = (signed char*)State->Data;
  1701.  
  1702.         while (SampleCount > 0)
  1703.             {
  1704.                 FastFixedType                LeftWeight;
  1705.                 long                                ArraySubscript;
  1706.                 signed long                    LeftValue;
  1707.                 signed long                    RightValue;
  1708.  
  1709.                 /* L+F(R-L) */
  1710.                 LeftWeight = LongLongLowHalf(LocalSamplePosition) >> (32 - FASTFIXEDPRECISION);
  1711.                 ArraySubscript = LongLongHighHalf(LocalSamplePosition);
  1712.                 PRNGCHK(SampleData,&(SampleData[ArraySubscript]),
  1713.                     sizeof(SampleData[ArraySubscript]));
  1714.                 LeftValue = ((signed long)SampleData[ArraySubscript]) << 8; /* convert to 16-bit */
  1715.                 PRNGCHK(SampleData,&(SampleData[ArraySubscript + 1]),
  1716.                     sizeof(SampleData[ArraySubscript + 1]));
  1717.                 RightValue = ((signed long)SampleData[ArraySubscript + 1]) << 8; /* to 16-bit */
  1718.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalOverallLoudness,LeftValue
  1719.                     + ((LeftWeight * (RightValue - LeftValue)) >> 15));
  1720.                 LongLongAdd(&LocalSamplePosition,&LocalSamplePositionDifferential);
  1721.              CheapDoLoop:
  1722.                 if (LongLongHighHalf(LocalSamplePosition) >= LocalCurrentLoopEnd)
  1723.                     {
  1724.                         if (State->LoopState != eNoLoop)
  1725.                             {
  1726.                                 /* handle loop */
  1727.                                 LongLongSetHighHalf(LocalSamplePosition,LongLongHighHalf(
  1728.                                     LocalSamplePosition) - State->CurrentLoopLength);
  1729.                                 goto CheapDoLoop;
  1730.                             }
  1731.                          else
  1732.                             {
  1733.                                 /* end of sample -- terminate */
  1734.                                 State->LoopState = eSampleFinished;
  1735.                                 goto BreakLoopPoint;
  1736.                             }
  1737.                     }
  1738.                 SampleCount -= 1;
  1739.             }
  1740.      BreakLoopPoint:
  1741.         ;
  1742.  
  1743.         State->SamplePosition = LocalSamplePosition;
  1744.     }
  1745.  
  1746.  
  1747. static void                        Sample_StereoOut_MonoSamp_8BitIn_YesTime(SampleStateRec* State,
  1748.                                                 long SampleCount, largefixedsigned* RawBuffer)
  1749.     {
  1750.         LongLongRec                    LocalSamplePosition;
  1751.         LongLongRec                    LocalSamplePositionDifferential;
  1752.         long                                LocalCurrentLoopEnd;
  1753.         FastFixedType                LocalLeftLoudness;
  1754.         FastFixedType                LocalRightLoudness;
  1755.         signed char*                SampleData;
  1756.  
  1757.         LocalLeftLoudness = State->LeftLoudness;
  1758.         LocalRightLoudness = State->RightLoudness;
  1759.         LocalSamplePosition = State->SamplePosition;
  1760.         LocalSamplePositionDifferential = State->SamplePositionDifferential;
  1761.         LocalCurrentLoopEnd = State->CurrentLoopEnd;
  1762.         SampleData = (signed char*)State->Data;
  1763.  
  1764.         while (SampleCount > 0)
  1765.             {
  1766.                 FastFixedType                LeftWeight;
  1767.                 long                                ArraySubscript;
  1768.                 signed long                    LeftValue;
  1769.                 signed long                    RightValue;
  1770.                 signed long                    CombinedValue;
  1771.  
  1772.                 /* L+F(R-L) */
  1773.                 LeftWeight = LongLongLowHalf(LocalSamplePosition) >> (32 - FASTFIXEDPRECISION);
  1774.                 ArraySubscript = LongLongHighHalf(LocalSamplePosition);
  1775.                 PRNGCHK(SampleData,&(SampleData[ArraySubscript]),
  1776.                     sizeof(SampleData[ArraySubscript]));
  1777.                 LeftValue = ((signed long)SampleData[ArraySubscript]) << 8; /* convert to 16-bit */
  1778.                 PRNGCHK(SampleData,&(SampleData[ArraySubscript + 1]),
  1779.                     sizeof(SampleData[ArraySubscript + 1]));
  1780.                 RightValue = ((signed long)SampleData[ArraySubscript + 1]) << 8; /* to 16-bit */
  1781.                 CombinedValue = LeftValue + ((LeftWeight * (RightValue - LeftValue)) >> 15);
  1782.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalLeftLoudness,CombinedValue);
  1783.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalRightLoudness,CombinedValue);
  1784.                 LongLongAdd(&LocalSamplePosition,&LocalSamplePositionDifferential);
  1785.              CheapDoLoop:
  1786.                 if (LongLongHighHalf(LocalSamplePosition) >= LocalCurrentLoopEnd)
  1787.                     {
  1788.                         if (State->LoopState != eNoLoop)
  1789.                             {
  1790.                                 /* handle loop */
  1791.                                 LongLongSetHighHalf(LocalSamplePosition,LongLongHighHalf(
  1792.                                     LocalSamplePosition) - State->CurrentLoopLength);
  1793.                                 goto CheapDoLoop;
  1794.                             }
  1795.                          else
  1796.                             {
  1797.                                 /* end of sample -- terminate */
  1798.                                 State->LoopState = eSampleFinished;
  1799.                                 goto BreakLoopPoint;
  1800.                             }
  1801.                     }
  1802.                 SampleCount -= 1;
  1803.             }
  1804.      BreakLoopPoint:
  1805.         ;
  1806.  
  1807.         State->SamplePosition = LocalSamplePosition;
  1808.     }
  1809.  
  1810.  
  1811. static void                        Sample_MonoOut_StereoSamp_8BitIn_YesTime(SampleStateRec* State,
  1812.                                                 long SampleCount, largefixedsigned* RawBuffer)
  1813.     {
  1814.         LongLongRec                    LocalSamplePosition;
  1815.         LongLongRec                    LocalSamplePositionDifferential;
  1816.         long                                LocalCurrentLoopEnd;
  1817.         FastFixedType                LocalOverallLoudness;
  1818.         signed char*                SampleData;
  1819.  
  1820.         LocalOverallLoudness = State->OverallLoudness;
  1821.         LocalSamplePosition = State->SamplePosition;
  1822.         LocalSamplePositionDifferential = State->SamplePositionDifferential;
  1823.         LocalCurrentLoopEnd = State->CurrentLoopEnd;
  1824.         SampleData = (signed char*)State->Data;
  1825.  
  1826.         while (SampleCount > 0)
  1827.             {
  1828.                 FastFixedType                LeftWeight;
  1829.                 long                                ArraySubscript;
  1830.                 signed long                    LeftValue;
  1831.                 signed long                    RightValue;
  1832.  
  1833.                 /* L+F(R-L) */
  1834.                 LeftWeight = LongLongLowHalf(LocalSamplePosition) >> (32 - FASTFIXEDPRECISION);
  1835.                 ArraySubscript = LongLongHighHalf(LocalSamplePosition);
  1836.                 PRNGCHK(SampleData,&(SampleData[2 * ArraySubscript + 0]),
  1837.                     sizeof(SampleData[2 * ArraySubscript + 0]));
  1838.                 PRNGCHK(SampleData,&(SampleData[2 * ArraySubscript + 1]),
  1839.                     sizeof(SampleData[2 * ArraySubscript + 1]));
  1840.                 LeftValue = ((signed long)SampleData[2 * ArraySubscript + 0]
  1841.                     + (signed long)SampleData[2 * ArraySubscript + 1]) << 7; /* convert to 16-bit */
  1842.                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 1) + 0]),
  1843.                     sizeof(SampleData[2 * (ArraySubscript + 1) + 0]));
  1844.                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 1) + 1]),
  1845.                     sizeof(SampleData[2 * (ArraySubscript + 1) + 1]));
  1846.                 RightValue = ((signed long)SampleData[2 * (ArraySubscript + 1) + 0]
  1847.                     + (signed long)SampleData[2 * (ArraySubscript + 1) + 1]) << 7; /* to 16-bit */
  1848.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalOverallLoudness,LeftValue
  1849.                     + ((LeftWeight * (RightValue - LeftValue)) >> 15));
  1850.                 LongLongAdd(&LocalSamplePosition,&LocalSamplePositionDifferential);
  1851.              CheapDoLoop:
  1852.                 if (LongLongHighHalf(LocalSamplePosition) >= LocalCurrentLoopEnd)
  1853.                     {
  1854.                         if (State->LoopState != eNoLoop)
  1855.                             {
  1856.                                 /* handle loop */
  1857.                                 LongLongSetHighHalf(LocalSamplePosition,LongLongHighHalf(
  1858.                                     LocalSamplePosition) - State->CurrentLoopLength);
  1859.                                 goto CheapDoLoop;
  1860.                             }
  1861.                          else
  1862.                             {
  1863.                                 /* end of sample -- terminate */
  1864.                                 State->LoopState = eSampleFinished;
  1865.                                 goto BreakLoopPoint;
  1866.                             }
  1867.                     }
  1868.                 SampleCount -= 1;
  1869.             }
  1870.      BreakLoopPoint:
  1871.         ;
  1872.  
  1873.         State->SamplePosition = LocalSamplePosition;
  1874.     }
  1875.  
  1876.  
  1877. static void                        Sample_StereoOut_StereoSamp_8BitIn_YesTime(SampleStateRec* State,
  1878.                                                 long SampleCount, largefixedsigned* RawBuffer)
  1879.     {
  1880.         LongLongRec                    LocalSamplePosition;
  1881.         LongLongRec                    LocalSamplePositionDifferential;
  1882.         long                                LocalCurrentLoopEnd;
  1883.         FastFixedType                LocalLeftLoudness;
  1884.         FastFixedType                LocalRightLoudness;
  1885.         signed char*                SampleData;
  1886.  
  1887.         LocalLeftLoudness = State->LeftLoudness;
  1888.         LocalRightLoudness = State->RightLoudness;
  1889.         LocalSamplePosition = State->SamplePosition;
  1890.         LocalSamplePositionDifferential = State->SamplePositionDifferential;
  1891.         LocalCurrentLoopEnd = State->CurrentLoopEnd;
  1892.         SampleData = (signed char*)State->Data;
  1893.  
  1894.         while (SampleCount > 0)
  1895.             {
  1896.                 FastFixedType                LeftWeight;
  1897.                 long                                ArraySubscript;
  1898.                 signed long                    LeftValue;
  1899.                 signed long                    RightValue;
  1900.  
  1901.                 /* L+F(R-L) */
  1902.                 LeftWeight = LongLongLowHalf(LocalSamplePosition) >> (32 - FASTFIXEDPRECISION);
  1903.                 ArraySubscript = LongLongHighHalf(LocalSamplePosition);
  1904.                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 0)]),
  1905.                     sizeof(SampleData[2 * (ArraySubscript + 0)]));
  1906.                 LeftValue = ((signed long)SampleData[2 * (ArraySubscript + 0)]) << 8; /* convert to 16-bit */
  1907.                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 1)]),
  1908.                     sizeof(SampleData[2 * (ArraySubscript + 1)]));
  1909.                 RightValue = ((signed long)SampleData[2 * (ArraySubscript + 1)]) << 8; /* to 16-bit */
  1910.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalLeftLoudness,LeftValue
  1911.                     + ((LeftWeight * (RightValue - LeftValue)) >> 15));
  1912.                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 0) + 1]),
  1913.                     sizeof(SampleData[2 * (ArraySubscript + 0) + 1]));
  1914.                 LeftValue = ((signed long)SampleData[2 * (ArraySubscript + 0) + 1]) << 8; /* convert to 16-bit */
  1915.                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 1) + 1]),
  1916.                     sizeof(SampleData[2 * (ArraySubscript + 1) + 1]));
  1917.                 RightValue = ((signed long)SampleData[2 * (ArraySubscript + 1) + 1]) << 8; /* to 16-bit */
  1918.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalRightLoudness,LeftValue
  1919.                     + ((LeftWeight * (RightValue - LeftValue)) >> 15));
  1920.                 LongLongAdd(&LocalSamplePosition,&LocalSamplePositionDifferential);
  1921.              CheapDoLoop:
  1922.                 if (LongLongHighHalf(LocalSamplePosition) >= LocalCurrentLoopEnd)
  1923.                     {
  1924.                         if (State->LoopState != eNoLoop)
  1925.                             {
  1926.                                 /* handle loop */
  1927.                                 LongLongSetHighHalf(LocalSamplePosition,LongLongHighHalf(
  1928.                                     LocalSamplePosition) - State->CurrentLoopLength);
  1929.                                 goto CheapDoLoop;
  1930.                             }
  1931.                          else
  1932.                             {
  1933.                                 /* end of sample -- terminate */
  1934.                                 State->LoopState = eSampleFinished;
  1935.                                 goto BreakLoopPoint;
  1936.                             }
  1937.                     }
  1938.                 SampleCount -= 1;
  1939.             }
  1940.      BreakLoopPoint:
  1941.         ;
  1942.  
  1943.         State->SamplePosition = LocalSamplePosition;
  1944.     }
  1945.  
  1946.  
  1947. static void                        Sample_MonoOut_MonoSamp_16BitIn_YesTime(SampleStateRec* State,
  1948.                                                 long SampleCount, largefixedsigned* RawBuffer)
  1949.     {
  1950.         LongLongRec                    LocalSamplePosition;
  1951.         LongLongRec                    LocalSamplePositionDifferential;
  1952.         long                                LocalCurrentLoopEnd;
  1953.         FastFixedType                LocalOverallLoudness;
  1954.         signed short*                SampleData;
  1955.  
  1956.         LocalOverallLoudness = State->OverallLoudness;
  1957.         LocalSamplePosition = State->SamplePosition;
  1958.         LocalSamplePositionDifferential = State->SamplePositionDifferential;
  1959.         LocalCurrentLoopEnd = State->CurrentLoopEnd;
  1960.         SampleData = (signed short*)State->Data;
  1961.  
  1962.         while (SampleCount > 0)
  1963.             {
  1964.                 FastFixedType                LeftWeight;
  1965.                 long                                ArraySubscript;
  1966.                 signed long                    LeftValue;
  1967.                 signed long                    RightValue;
  1968.  
  1969.                 /* L+F(R-L) */
  1970.                 LeftWeight = LongLongLowHalf(LocalSamplePosition) >> (32 - FASTFIXEDPRECISION);
  1971.                 ArraySubscript = LongLongHighHalf(LocalSamplePosition);
  1972.                 PRNGCHK(SampleData,&(SampleData[ArraySubscript]),
  1973.                     sizeof(SampleData[ArraySubscript]));
  1974.                 LeftValue = SampleData[ArraySubscript];
  1975.                 PRNGCHK(SampleData,&(SampleData[ArraySubscript + 1]),
  1976.                     sizeof(SampleData[ArraySubscript + 1]));
  1977.                 RightValue = SampleData[ArraySubscript + 1];
  1978.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalOverallLoudness,LeftValue
  1979.                     + ((LeftWeight * (RightValue - LeftValue)) >> 15));
  1980.                 LongLongAdd(&LocalSamplePosition,&LocalSamplePositionDifferential);
  1981.              CheapDoLoop:
  1982.                 if (LongLongHighHalf(LocalSamplePosition) >= LocalCurrentLoopEnd)
  1983.                     {
  1984.                         if (State->LoopState != eNoLoop)
  1985.                             {
  1986.                                 /* handle loop */
  1987.                                 LongLongSetHighHalf(LocalSamplePosition,LongLongHighHalf(
  1988.                                     LocalSamplePosition) - State->CurrentLoopLength);
  1989.                                 goto CheapDoLoop;
  1990.                             }
  1991.                          else
  1992.                             {
  1993.                                 /* end of sample -- terminate */
  1994.                                 State->LoopState = eSampleFinished;
  1995.                                 goto BreakLoopPoint;
  1996.                             }
  1997.                     }
  1998.                 SampleCount -= 1;
  1999.             }
  2000.      BreakLoopPoint:
  2001.         ;
  2002.  
  2003.         State->SamplePosition = LocalSamplePosition;
  2004.     }
  2005.  
  2006.  
  2007. static void                        Sample_StereoOut_MonoSamp_16BitIn_YesTime(SampleStateRec* State,
  2008.                                                 long SampleCount, largefixedsigned* RawBuffer)
  2009.     {
  2010.         LongLongRec                    LocalSamplePosition;
  2011.         LongLongRec                    LocalSamplePositionDifferential;
  2012.         long                                LocalCurrentLoopEnd;
  2013.         FastFixedType                LocalLeftLoudness;
  2014.         FastFixedType                LocalRightLoudness;
  2015.         signed short*                SampleData;
  2016.  
  2017.         LocalLeftLoudness = State->LeftLoudness;
  2018.         LocalRightLoudness = State->RightLoudness;
  2019.         LocalSamplePosition = State->SamplePosition;
  2020.         LocalSamplePositionDifferential = State->SamplePositionDifferential;
  2021.         LocalCurrentLoopEnd = State->CurrentLoopEnd;
  2022.         SampleData = (signed short*)State->Data;
  2023.  
  2024.         while (SampleCount > 0)
  2025.             {
  2026.                 FastFixedType                LeftWeight;
  2027.                 long                                ArraySubscript;
  2028.                 signed long                    LeftValue;
  2029.                 signed long                    RightValue;
  2030.                 signed long                    CombinedValue;
  2031.  
  2032.                 /* L+F(R-L) */
  2033.                 LeftWeight = LongLongLowHalf(LocalSamplePosition) >> (32 - FASTFIXEDPRECISION);
  2034.                 ArraySubscript = LongLongHighHalf(LocalSamplePosition);
  2035.                 PRNGCHK(SampleData,&(SampleData[ArraySubscript]),
  2036.                     sizeof(SampleData[ArraySubscript]));
  2037.                 LeftValue = SampleData[ArraySubscript];
  2038.                 PRNGCHK(SampleData,&(SampleData[ArraySubscript + 1]),
  2039.                     sizeof(SampleData[ArraySubscript + 1]));
  2040.                 RightValue = SampleData[ArraySubscript + 1];
  2041.                 CombinedValue = LeftValue + ((LeftWeight * (RightValue - LeftValue)) >> 15);
  2042.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalLeftLoudness,CombinedValue);
  2043.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalRightLoudness,CombinedValue);
  2044.                 LongLongAdd(&LocalSamplePosition,&LocalSamplePositionDifferential);
  2045.              CheapDoLoop:
  2046.                 if (LongLongHighHalf(LocalSamplePosition) >= LocalCurrentLoopEnd)
  2047.                     {
  2048.                         if (State->LoopState != eNoLoop)
  2049.                             {
  2050.                                 /* handle loop */
  2051.                                 LongLongSetHighHalf(LocalSamplePosition,LongLongHighHalf(
  2052.                                     LocalSamplePosition) - State->CurrentLoopLength);
  2053.                                 goto CheapDoLoop;
  2054.                             }
  2055.                          else
  2056.                             {
  2057.                                 /* end of sample -- terminate */
  2058.                                 State->LoopState = eSampleFinished;
  2059.                                 goto BreakLoopPoint;
  2060.                             }
  2061.                     }
  2062.                 SampleCount -= 1;
  2063.             }
  2064.      BreakLoopPoint:
  2065.         ;
  2066.  
  2067.         State->SamplePosition = LocalSamplePosition;
  2068.     }
  2069.  
  2070.  
  2071. static void                        Sample_MonoOut_StereoSamp_16BitIn_YesTime(SampleStateRec* State,
  2072.                                                 long SampleCount, largefixedsigned* RawBuffer)
  2073.     {
  2074.         LongLongRec                    LocalSamplePosition;
  2075.         LongLongRec                    LocalSamplePositionDifferential;
  2076.         long                                LocalCurrentLoopEnd;
  2077.         FastFixedType                LocalOverallLoudness;
  2078.         signed short*                SampleData;
  2079.  
  2080.         LocalOverallLoudness = State->OverallLoudness;
  2081.         LocalSamplePosition = State->SamplePosition;
  2082.         LocalSamplePositionDifferential = State->SamplePositionDifferential;
  2083.         LocalCurrentLoopEnd = State->CurrentLoopEnd;
  2084.         SampleData = (signed short*)State->Data;
  2085.  
  2086.         while (SampleCount > 0)
  2087.             {
  2088.                 FastFixedType                LeftWeight;
  2089.                 long                                ArraySubscript;
  2090.                 signed long                    LeftValue;
  2091.                 signed long                    RightValue;
  2092.  
  2093.                 /* L+F(R-L) */
  2094.                 LeftWeight = LongLongLowHalf(LocalSamplePosition) >> (32 - FASTFIXEDPRECISION);
  2095.                 ArraySubscript = LongLongHighHalf(LocalSamplePosition);
  2096.                 PRNGCHK(SampleData,&(SampleData[2 * ArraySubscript + 0]),
  2097.                     sizeof(SampleData[2 * ArraySubscript + 0]));
  2098.                 PRNGCHK(SampleData,&(SampleData[2 * ArraySubscript + 1]),
  2099.                     sizeof(SampleData[2 * ArraySubscript + 1]));
  2100.                 LeftValue = ((signed long)SampleData[2 * ArraySubscript + 0]
  2101.                     + (signed long)SampleData[2 * ArraySubscript + 1]) >> 1;
  2102.                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 1) + 0]),
  2103.                     sizeof(SampleData[2 * (ArraySubscript + 1) + 0]));
  2104.                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 1) + 1]),
  2105.                     sizeof(SampleData[2 * (ArraySubscript + 1) + 1]));
  2106.                 RightValue = ((signed long)SampleData[2 * (ArraySubscript + 1) + 0]
  2107.                     + (signed long)SampleData[2 * (ArraySubscript + 1) + 1]) >> 1;
  2108.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalOverallLoudness,LeftValue
  2109.                     + ((LeftWeight * (RightValue - LeftValue)) >> 15));
  2110.                 LongLongAdd(&LocalSamplePosition,&LocalSamplePositionDifferential);
  2111.              CheapDoLoop:
  2112.                 if (LongLongHighHalf(LocalSamplePosition) >= LocalCurrentLoopEnd)
  2113.                     {
  2114.                         if (State->LoopState != eNoLoop)
  2115.                             {
  2116.                                 /* handle loop */
  2117.                                 LongLongSetHighHalf(LocalSamplePosition,LongLongHighHalf(
  2118.                                     LocalSamplePosition) - State->CurrentLoopLength);
  2119.                                 goto CheapDoLoop;
  2120.                             }
  2121.                          else
  2122.                             {
  2123.                                 /* end of sample -- terminate */
  2124.                                 State->LoopState = eSampleFinished;
  2125.                                 goto BreakLoopPoint;
  2126.                             }
  2127.                     }
  2128.                 SampleCount -= 1;
  2129.             }
  2130.      BreakLoopPoint:
  2131.         ;
  2132.  
  2133.         State->SamplePosition = LocalSamplePosition;
  2134.     }
  2135.  
  2136.  
  2137. static void                        Sample_StereoOut_StereoSamp_16BitIn_YesTime(SampleStateRec* State,
  2138.                                                 long SampleCount, largefixedsigned* RawBuffer)
  2139.     {
  2140.         LongLongRec                    LocalSamplePosition;
  2141.         LongLongRec                    LocalSamplePositionDifferential;
  2142.         long                                LocalCurrentLoopEnd;
  2143.         FastFixedType                LocalLeftLoudness;
  2144.         FastFixedType                LocalRightLoudness;
  2145.         signed short*                SampleData;
  2146.  
  2147.         LocalLeftLoudness = State->LeftLoudness;
  2148.         LocalRightLoudness = State->RightLoudness;
  2149.         LocalSamplePosition = State->SamplePosition;
  2150.         LocalSamplePositionDifferential = State->SamplePositionDifferential;
  2151.         LocalCurrentLoopEnd = State->CurrentLoopEnd;
  2152.         SampleData = (signed short*)State->Data;
  2153.  
  2154.         while (SampleCount > 0)
  2155.             {
  2156.                 FastFixedType                LeftWeight;
  2157.                 long                                ArraySubscript;
  2158.                 signed long                    LeftValue;
  2159.                 signed long                    RightValue;
  2160.  
  2161.                 /* L+F(R-L) */
  2162.                 LeftWeight = LongLongLowHalf(LocalSamplePosition) >> (32 - FASTFIXEDPRECISION);
  2163.                 ArraySubscript = LongLongHighHalf(LocalSamplePosition);
  2164.                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 0)]),
  2165.                     sizeof(SampleData[2 * (ArraySubscript + 0)]));
  2166.                 LeftValue = SampleData[2 * (ArraySubscript + 0)];
  2167.                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 1)]),
  2168.                     sizeof(SampleData[2 * (ArraySubscript + 1)]));
  2169.                 RightValue = SampleData[2 * (ArraySubscript + 1)];
  2170.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalLeftLoudness,LeftValue
  2171.                     + ((LeftWeight * (RightValue - LeftValue)) >> 15));
  2172.                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 0) + 1]),
  2173.                     sizeof(SampleData[2 * (ArraySubscript + 0) + 1]));
  2174.                 LeftValue = SampleData[2 * (ArraySubscript + 0) + 1];
  2175.                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 1) + 1]),
  2176.                     sizeof(SampleData[2 * (ArraySubscript + 1) + 1]));
  2177.                 RightValue = SampleData[2 * (ArraySubscript + 1) + 1];
  2178.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalRightLoudness,LeftValue
  2179.                     + ((LeftWeight * (RightValue - LeftValue)) >> 15));
  2180.                 LongLongAdd(&LocalSamplePosition,&LocalSamplePositionDifferential);
  2181.              CheapDoLoop:
  2182.                 if (LongLongHighHalf(LocalSamplePosition) >= LocalCurrentLoopEnd)
  2183.                     {
  2184.                         if (State->LoopState != eNoLoop)
  2185.                             {
  2186.                                 /* handle loop */
  2187.                                 LongLongSetHighHalf(LocalSamplePosition,LongLongHighHalf(
  2188.                                     LocalSamplePosition) - State->CurrentLoopLength);
  2189.                                 goto CheapDoLoop;
  2190.                             }
  2191.                          else
  2192.                             {
  2193.                                 /* end of sample -- terminate */
  2194.                                 State->LoopState = eSampleFinished;
  2195.                                 goto BreakLoopPoint;
  2196.                             }
  2197.                     }
  2198.                 SampleCount -= 1;
  2199.             }
  2200.      BreakLoopPoint:
  2201.         ;
  2202.  
  2203.         State->SamplePosition = LocalSamplePosition;
  2204.     }
  2205.  
  2206.  
  2207. static void                        Sample_NoOutput(SampleStateRec* State,
  2208.                                                 long SampleCount, largefixedsigned* RawBuffer)
  2209.     {
  2210.     }
  2211.